cfix 1.0.0

package/src/index.js

@@ -0,0 +1,1658 @@
+require("dotenv").config();
+const Koa = require("koa");
+const Router = require("koa-router");
+const bodyParser = require("koa-bodyparser");
+const cors = require("@koa/cors");
+const path = require("path");
+const koaStatic = require("koa-static");
+const ClaudeCLIService = require("./claude-cli-service");
+const GitService = require("./git-service");
+const WeChatNotifier = require("./wechat-notifier");
+const NotificationService = require("./services/notification-service");
+const ExecUtil = require("./utils/exec");
+const taskManager = require("./task-manager");
+const { logger, generateRequestId, createContextLogger } = require("./logger");
+const InputSanitizer = require("./utils/sanitizer");
+const { apiLimiter, strictLimiter } = require("./middleware/rate-limit");
+const { authenticateAPI, ipWhitelist } = require("./middleware/auth");
+const metrics = require("./metrics/collector");
+const config = require("./config");
+const projectLock = require("./utils/project-lock");
+
+// 尝试加载任务队列（可选依赖）
+let taskQueue = null;
+try {
+  taskQueue = require("./queue/task-queue");
+  logger.info("📋 任务队列模块已加载");
+} catch (error) {
+  logger.warn("⚠️ 任务队列模块加载失败（将使用直接执行模式）", {
+    error: error.message,
+  });
+}
+
+// 尝试加载 WebSocket 通知服务（可选依赖）
+let wsNotifier = null;
+try {
+  wsNotifier = require("./websocket/notifier");
+  logger.info("📡 WebSocket 通知模块已加载");
+} catch (error) {
+  logger.warn("⚠️ WebSocket 通知模块未安装（可选功能）", {
+    suggestion: "运行 npm run install:ws 安装 WebSocket 支持",
+  });
+}
+
+const app = new Koa();
+const router = new Router();
+
+// CORS 配置
+const corsOptions = {
+  origin: process.env.CORS_ORIGIN || "*", // 允许的来源，默认允许所有
+  allowMethods: ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+  allowHeaders: ["Content-Type", "Authorization"],
+  credentials: true,
+  maxAge: 86400, // 预检请求缓存时间（24小时）
+};
+
+// 应用中间件
+app.use(cors(corsOptions));
+app.use(bodyParser());
+
+// 静态文件服务（用于 WebSocket 监控面板）
+app.use(koaStatic(path.join(__dirname, "../public")));
+
+// 请求追踪中间件
+app.use(async (ctx, next) => {
+  const requestId = generateRequestId();
+  const startTime = Date.now();
+
+  ctx.requestId = requestId;
+  ctx.logger = createContextLogger({ requestId });
+
+  ctx.logger.info("收到请求", {
+    method: ctx.method,
+    path: ctx.path,
+    ip: ctx.ip,
+  });
+
+  await next();
+
+  // 记录 HTTP 请求指标
+  const duration = Date.now() - startTime;
+  const isError = ctx.status >= 400;
+  metrics.recordHTTPRequest(duration, isError);
+
+  ctx.logger.info("请求完成", {
+    status: ctx.status,
+    duration: `${duration}ms`,
+  });
+});
+
+// 对所有 API 路由应用通用频率限制
+app.use(apiLimiter);
+
+// 全局错误处理
+app.use(async (ctx, next) => {
+  try {
+    await next();
+  } catch (err) {
+    ctx.status = err.status || 500;
+    ctx.body = {
+      success: false,
+      error: err.message,
+    };
+    logger.error(`请求错误: ${err.message}`, {
+      path: ctx.path,
+      method: ctx.method,
+      error: err.stack,
+      requestId: ctx.requestId,
+    });
+  }
+});
+
+// 初始化服务
+const claudeCLIService = new ClaudeCLIService(config.get("ai.claudeCLI"));
+const wechatNotifier = new WeChatNotifier(
+  config.get("notification.wecomWebhook")
+);
+
+// 初始化统一通知服务
+const notificationService = new NotificationService(
+  config.get("notification"),
+  wechatNotifier,
+  wsNotifier
+);
+
+// 选择 AI 引擎
+function getAIService(engine) {
+  engine = engine || config.get("ai.defaultEngine");
+  if (engine === "claude-cli") {
+    return { service: claudeCLIService, name: "Claude CLI" };
+  } else {
+    throw new Error(`未知的 AI 引擎: ${engine}`);
+  }
+}
+
+// 🔑 设置任务队列处理器（如果启用了队列）
+if (taskQueue) {
+  taskQueue.process(async (job) => {
+    const { taskId, params } = job.data;
+
+    logger.info(`📋 队列任务开始: ${taskId}`, {
+      taskId,
+      queueJobId: job.id,
+    });
+
+    try {
+      // 执行任务
+      await executeFixTask(taskId, params);
+
+      logger.info(`✅ 队列任务完成: ${taskId}`, {
+        taskId,
+        queueJobId: job.id,
+      });
+
+      return { success: true, taskId };
+    } catch (error) {
+      logger.error(`❌ 队列任务失败: ${taskId}`, {
+        taskId,
+        queueJobId: job.id,
+        error: error.message,
+      });
+
+      throw error; // 让队列处理重试逻辑
+    }
+  });
+
+  logger.info("✅ 任务队列处理器已设置");
+}
+
+/**
+ * 执行 Git 操作（提交、推送、合并）
+ * @param {string} taskId - 任务ID
+ * @param {string} workingDir - 工作目录
+ * @param {string} branchName - 分支名称
+ * @param {string} projectName - 项目名称
+ * @param {string} aiName - AI 引擎名称
+ * @param {object} fixResult - 修复结果
+ * @param {object} options - 选项
+ */
+async function performGitOperations(
+  taskId,
+  workingDir,
+  branchName,
+  projectName,
+  aiName,
+  fixResult,
+  options
+) {
+  const {
+    runTests = false,
+    autoPush = true,
+    requirement,
+    mergeToAlpha = false,
+    mergeToBeta = false,
+    mergeToMaster = false,
+  } = options;
+
+  // 1. 运行测试（可选）
+  let testsPassed = true;
+  if (runTests) {
+    taskManager.updateProgress(taskId, "running_tests", "运行测试");
+    if (wsNotifier) {
+      wsNotifier.notifyTaskProgress(taskId, "running_tests", "运行测试", 60);
+    }
+    testsPassed = GitService.runTests(workingDir);
+    if (!testsPassed) {
+      logger.warn("⚠️ 测试未通过，但继续提交流程", { taskId });
+    }
+  }
+
+  // 2. 提交更改
+  taskManager.updateProgress(taskId, "committing", "提交更改");
+  if (wsNotifier) {
+    wsNotifier.notifyTaskProgress(taskId, "committing", "提交更改", 70);
+  }
+  const commitMessage = `fix: ${requirement.substring(0, 50)}${
+    requirement.length > 50 ? "..." : ""
+  }
+
+🤖 由 ${aiName} 自动生成
+
+修改文件:
+${fixResult.changedFiles.map((f) => `- ${f}`).join("\n")}`;
+
+  const hasCommit = GitService.commit(workingDir, commitMessage);
+
+  // 3. 推送到远程（可选）
+  let pushed = false;
+  if (hasCommit && autoPush) {
+    taskManager.updateProgress(taskId, "pushing", "推送到远程仓库");
+    if (wsNotifier) {
+      wsNotifier.notifyTaskProgress(taskId, "pushing", "推送到远程仓库", 80);
+    }
+    pushed = await GitService.push(workingDir, branchName);
+  }
+
+  // 4. 合并到目标分支（可选）
+  let mergeResults = {};
+  const targetBranches = [];
+
+  if (mergeToAlpha) targetBranches.push("alpha");
+  if (mergeToBeta) targetBranches.push("beta");
+  if (mergeToMaster) targetBranches.push("master");
+
+  if (targetBranches.length > 0) {
+    taskManager.updateProgress(
+      taskId,
+      "merging",
+      `合并到 ${targetBranches.join(", ")}`
+    );
+    if (wsNotifier) {
+      wsNotifier.notifyTaskProgress(
+        taskId,
+        "merging",
+        `合并到 ${targetBranches.join(", ")}`,
+        90
+      );
+    }
+    mergeResults = await GitService.mergeToMultipleBranches(
+      workingDir,
+      branchName,
+      targetBranches
+    );
+
+    logger.info("📊 合并结果:", { taskId });
+    for (const [branch, success] of Object.entries(mergeResults)) {
+      logger.info(`   - ${branch}: ${success ? "✅ 成功" : "❌ 失败"}`, {
+        taskId,
+      });
+    }
+  }
+
+  // 5. 发送成功通知
+  taskManager.updateProgress(
+    taskId,
+    "sending_success_notification",
+    "发送成功通知"
+  );
+
+  // 6. 完成任务
+  const result = {
+    success: true,
+    aiEngine: aiName,
+    projectName,
+    projectPath: workingDir,
+    branch: branchName,
+    branchName,
+    changedFiles: fixResult.changedFiles,
+    summary: fixResult.summary,
+    fullOutput: fixResult.fullOutput,
+    conversationTurns: fixResult.conversationTurns,
+    testsPassed,
+    pushed,
+    mergeResults,
+  };
+
+  taskManager.completeTask(taskId, result);
+
+  // 发送任务完成通知
+  await notificationService.notifyTaskComplete(taskId, result);
+
+  // 注销进程
+  taskManager.unregisterProcess(taskId);
+
+  // 🔑 释放项目锁
+  projectLock.releaseLock(workingDir, taskId);
+  logger.info(`🔓 任务完成，释放项目锁: ${workingDir}`, { taskId });
+
+  logger.info("=".repeat(60));
+  logger.info(`✅ 任务 ${taskId} 完成!`, { taskId });
+  logger.info("=".repeat(60));
+  logger.info(JSON.stringify(result, null, 2), { taskId });
+
+  return result;
+}
+
+/**
+ * 异步执行修复任务
+ */
+async function executeFixTask(taskId, params) {
+  const {
+    projectPath,
+    repoUrl,
+    requirement,
+    runTests = false,
+    autoPush = true,
+    aiEngine,
+    baseBranch = null, // 基准分支
+    createNewBranch = true, // 是否创建新分支
+    username = "system", // 用户名
+    mergeToAlpha = false, // 是否合并到 alpha
+    mergeToBeta = false, // 是否合并到 beta
+    mergeToMaster = false, // 是否合并到 master
+  } = params;
+
+  let workingDir = null;
+  let branchName = null;
+  let cancelled = false;
+  let childProcessCancel = null; // 子进程取消函数
+
+  // 注册取消函数（初始版本，只设置标志位）
+  taskManager.registerProcess(taskId, {
+    cancel: () => {
+      cancelled = true;
+      logger.warn(`⚠️ 任务 ${taskId} 收到取消请求`, { taskId });
+
+      // 如果子进程已经启动，也调用子进程的取消函数
+      if (childProcessCancel) {
+        logger.info("🛑 同时终止子进程...", { taskId });
+        childProcessCancel();
+      }
+    },
+  });
+
+  try {
+    taskManager.startTask(taskId);
+
+    // WebSocket 通知：任务开始
+    if (wsNotifier) {
+      wsNotifier.notifyTaskStatus(taskId, "running", {
+        message: "任务已开始",
+        requirement,
+        projectPath: workingDir,
+      });
+    }
+
+    // 检查是否已取消
+    if (cancelled) {
+      throw new Error("任务已取消");
+    }
+
+    taskManager.updateProgress(taskId, "selecting_engine", "选择 AI 引擎");
+
+    // WebSocket 通知：进度更新
+    if (wsNotifier) {
+      wsNotifier.notifyTaskProgress(
+        taskId,
+        "selecting_engine",
+        "选择 AI 引擎",
+        5
+      );
+    }
+
+    const { service: aiService, name: aiName } = getAIService(aiEngine);
+
+    logger.info("=".repeat(60));
+    logger.info(`🚀 开始任务 ${taskId}`, { taskId });
+    logger.info("=".repeat(60));
+    logger.info(`📋 需求: ${requirement}`, { taskId });
+    logger.info(`🤖 AI 引擎: ${aiName}`, { taskId });
+
+    // 1. 确定工作目录
+    taskManager.updateProgress(taskId, "preparing_project", "准备项目目录");
+    if (wsNotifier) {
+      wsNotifier.notifyTaskProgress(
+        taskId,
+        "preparing_project",
+        "准备项目目录",
+        10
+      );
+    }
+
+    if (projectPath && GitService.projectExists(projectPath)) {
+      workingDir = projectPath;
+      logger.info(`📂 使用现有项目: ${workingDir}`, { taskId });
+
+      // 🔑 获取项目锁（如果项目已被其他任务锁定，当前任务会等待）
+      await projectLock.acquireLock(workingDir, taskId);
+
+      // 🔑 使用智能准备方法（处理各种分支状态）
+      await GitService.prepareExistingProject(workingDir, baseBranch);
+    } else if (repoUrl) {
+      const repoName = path.basename(repoUrl, ".git");
+      workingDir = path.join(config.get("server.workDir"), repoName);
+
+      if (GitService.projectExists(workingDir)) {
+        logger.info(`📂 项目已存在: ${workingDir}`, { taskId });
+
+        // 🔑 获取项目锁（如果项目已被其他任务锁定，当前任务会等待）
+        await projectLock.acquireLock(workingDir, taskId);
+
+        // 🔑 使用智能准备方法（处理各种分支状态）
+        await GitService.prepareExistingProject(workingDir, baseBranch);
+      } else {
+        logger.info(`📦 项目不存在，克隆仓库...`, { taskId });
+        GitService.cloneRepo(repoUrl, workingDir);
+
+        // 🔑 获取项目锁（新克隆的项目也需要锁定）
+        await projectLock.acquireLock(workingDir, taskId);
+      }
+    } else {
+      throw new Error("项目路径不存在且未提供仓库地址");
+    }
+
+    const projectName = GitService.getProjectName(workingDir);
+
+    // 发送开始通知
+    taskManager.updateProgress(taskId, "sending_notification", "发送开始通知");
+    await notificationService.notifyTaskStart(taskId, projectName, requirement);
+
+    // 2. 创建功能分支或切换到基准分支
+    if (createNewBranch) {
+      taskManager.updateProgress(taskId, "creating_branch", "创建功能分支");
+      if (wsNotifier) {
+        wsNotifier.notifyTaskProgress(
+          taskId,
+          "creating_branch",
+          "创建功能分支",
+          20
+        );
+      }
+      branchName = GitService.createBranch(
+        workingDir,
+        username,
+        taskId,
+        baseBranch
+      );
+    } else {
+      taskManager.updateProgress(taskId, "checkout_branch", "切换到基准分支");
+      if (wsNotifier) {
+        wsNotifier.notifyTaskProgress(
+          taskId,
+          "checkout_branch",
+          "切换到基准分支",
+          20
+        );
+      }
+      branchName = GitService.checkoutBranch(workingDir, baseBranch);
+      logger.info(`📌 直接在分支 ${branchName} 上进行开发`, { taskId });
+    }
+
+    // 3. 使用 AI 修复代码
+    taskManager.updateProgress(
+      taskId,
+      "fixing_code",
+      `使用 ${aiName} 修复代码`
+    );
+    if (wsNotifier) {
+      wsNotifier.notifyTaskProgress(
+        taskId,
+        "fixing_code",
+        `使用 ${aiName} 修复代码`,
+        30
+      );
+    }
+    logger.info(`🤖 启动 ${aiName} 进行代码修复...`, { taskId });
+    const fixResult = await aiService.fixCode(workingDir, requirement, {
+      onProcessCreated: (processInfo) => {
+        // 保存子进程的取消函数
+        if (processInfo.cancel) {
+          childProcessCancel = processInfo.cancel;
+          logger.debug(`已保存任务 ${taskId} 的子进程取消函数`, { taskId });
+        }
+      },
+    });
+
+    if (!fixResult.success) {
+      throw new Error(`${aiName} 修复失败`);
+    }
+
+    logger.info("-".repeat(60));
+    logger.info("📊 修复结果:", { taskId });
+    logger.info(`   - 修改文件数: ${fixResult.changedFiles.length}`, {
+      taskId,
+    });
+    logger.info(`   - 对话轮次: ${fixResult.conversationTurns || 1}`, {
+      taskId,
+    });
+    logger.info("-".repeat(60));
+
+    // 4. 检查是否需要等待确认
+    const needsApproval = params.needsApproval !== false; // 默认需要确认
+
+    if (needsApproval) {
+      // 🔑 等待开发者确认
+      logger.info("⏸️  AI 修复完成，等待开发者确认...", { taskId });
+      logger.info(`   - 修改文件数: ${fixResult.changedFiles.length}`, { taskId });
+      logger.info(`   - 查看修改: GET /api/tasks/${taskId}/changes`, { taskId });
+      logger.info(`   - 确认修改: POST /api/tasks/${taskId}/approve`, { taskId });
+      logger.info(`   - 拒绝修改: POST /api/tasks/${taskId}/reject`, { taskId });
+
+      // 保存修改信息到任务中，同时更新状态为 waiting_approval
+      taskManager.updateTask(taskId, {
+        status: "waiting_approval",
+        progress: {
+          step: "waiting_approval",
+          message: "等待开发者确认修改",
+        },
+        fixResult,
+        workingDir,
+        branchName,
+        projectName,
+        aiEngine: aiName,
+        // 保存后续需要的参数
+        pendingGitOperations: {
+          runTests,
+          autoPush,
+          requirement,
+          mergeToAlpha,
+          mergeToBeta,
+          mergeToMaster,
+        },
+      });
+
+      // 🔑 通知等待确认
+      notificationService.notifyWaitingApproval(taskId, fixResult.changedFiles);
+
+      if (wsNotifier) {
+        wsNotifier.notifyTaskProgress(
+          taskId,
+          "waiting_approval",
+          "AI 修复完成，等待开发者确认",
+          50
+        );
+      }
+
+      // 🔑 任务暂停，等待确认（不执行后续 Git 操作）
+      return;
+    }
+
+    // 如果不需要确认，继续执行 Git 操作
+    await performGitOperations(
+      taskId,
+      workingDir,
+      branchName,
+      projectName,
+      aiName,
+      fixResult,
+      {
+        runTests,
+        autoPush,
+        requirement,
+        mergeToAlpha,
+        mergeToBeta,
+        mergeToMaster,
+      }
+    );
+  } catch (error) {
+    logger.error(`❌ 任务 ${taskId} 失败: ${error.message}`, {
+      taskId,
+      error: error.stack,
+    });
+
+    // 注销进程
+    taskManager.unregisterProcess(taskId);
+
+    // WebSocket 通知：任务失败
+    if (wsNotifier) {
+      wsNotifier.notifyTaskFailed(taskId, error);
+    }
+
+    // 发送失败通知
+    if (workingDir) {
+      const projectName = GitService.getProjectName(workingDir);
+      await notificationService.notifyTaskFailure(
+        taskId,
+        projectName,
+        requirement,
+        error
+      );
+    }
+
+    taskManager.failTask(taskId, error);
+  } finally {
+    // 🔑 只在非等待确认状态时释放锁
+    // 等待确认状态需要在 approve/reject 后才释放锁
+    const task = taskManager.getTask(taskId);
+    if (workingDir && task?.status !== "waiting_approval") {
+      projectLock.releaseLock(workingDir, taskId);
+      logger.info(`🔓 释放项目锁: ${workingDir}`, { taskId });
+    } else if (task?.status === "waiting_approval") {
+      logger.info(`🔒 任务等待确认，保持项目锁: ${workingDir}`, { taskId });
+    }
+  }
+
+  // 清理旧任务
+  taskManager.cleanup();
+}
+
+/**
+ * 健康检查接口（增强版）
+ * GET /health
+ */
+router.get("/health", async (ctx) => {
+  const healthStatus = {
+    status: "ok",
+    service: "claude-auto-fix",
+    timestamp: new Date().toISOString(),
+    uptime: process.uptime(),
+    memory: process.memoryUsage(),
+    metrics: metrics.getMetrics(),
+  };
+
+  ctx.body = healthStatus;
+});
+
+/**
+ * 性能指标接口
+ * GET /api/metrics
+ */
+router.get("/api/metrics", async (ctx) => {
+  ctx.body = {
+    success: true,
+    metrics: metrics.getMetrics(),
+    timestamp: new Date().toISOString(),
+  };
+});
+
+/**
+ * 配置信息接口（敏感信息已脱敏）
+ * GET /api/config
+ */
+router.get("/api/config", authenticateAPI, async (ctx) => {
+  const configInfo = config.getAll();
+
+  // 脱敏处理
+  const safeConfig = {
+    server: configInfo.server,
+    ai: {
+      defaultEngine: configInfo.ai.defaultEngine,
+      claudeCLI: {
+        permissionMode: configInfo.ai.claudeCLI.permissionMode,
+        maxTurns: configInfo.ai.claudeCLI.maxTurns,
+      },
+    },
+    security: {
+      corsOrigin: configInfo.security.corsOrigin,
+      rateLimit: configInfo.security.rateLimit,
+      apiKeyConfigured: !!configInfo.security.apiKey,
+    },
+    notification: {
+      wecomConfigured: !!configInfo.notification.wecomWebhook,
+    },
+  };
+
+  ctx.body = {
+    success: true,
+    config: safeConfig,
+  };
+});
+
+/**
+ * 异步修复接口（推荐）
+ * POST /api/fix-bug
+ *
+ * Body:
+ * {
+ *   "projectPath": "e:\\demo\\my-project",  // 可选，本地项目路径
+ *   "repoUrl": "https://github.com/user/repo.git",  // 可选，远程仓库地址
+ *   "requirement": "修复登录按钮点击无反应的问题",  // 必填，修复要求
+ *   "runTests": false,  // 可选，是否运行测试，默认 false
+ *   "autoPush": true,   // 可选，是否自动推送，默认 true
+ *   "aiEngine": "claude-cli", // 可选，AI 引擎
+ *   "baseBranch": "develop", // 可选，基准分支，默认自动查找 main/master
+ *   "createNewBranch": true, // 可选，是否创建新分支，默认 true
+ *   "username": "zhangsan",  // 可选，用户名（用于分支命名），默认 system
+ *   "mergeToAlpha": false,   // 可选，是否合并到 alpha 分支
+ *   "mergeToBeta": false,    // 可选，是否合并到 beta 分支
+ *   "mergeToMaster": false,  // 可选，是否合并到 master 分支
+ *   "needsApproval": true    // 可选，是否需要人工确认后才执行 Git 操作，默认 true
+ * }
+ *
+ * Response:
+ * {
+ *   "success": true,
+ *   "taskId": "task-1234567890-abc123",
+ *   "message": "任务已创建，正在后台处理"
+ * }
+ */
+router.post("/api/fix-bug", strictLimiter, async (ctx) => {
+  try {
+    const {
+      projectPath: rawProjectPath,
+      repoUrl: rawRepoUrl,
+      requirement: rawRequirement,
+      runTests = false,
+      autoPush = true,
+      aiEngine: rawAiEngine,
+      baseBranch: rawBaseBranch = null,
+      createNewBranch = true,
+      username: rawUsername = "system",
+      mergeToAlpha = false,
+      mergeToBeta = false,
+      mergeToMaster = false,
+      needsApproval = true, // 是否需要人工确认，默认 true
+    } = ctx.request.body;
+
+    // 验证和清理输入
+    if (!rawRequirement) {
+      ctx.status = 400;
+      ctx.body = {
+        success: false,
+        error: "缺少必填参数: requirement",
+      };
+      return;
+    }
+
+    // 清理需求描述
+    const requirement = InputSanitizer.sanitizeRequirement(rawRequirement);
+
+    // 清理用户名
+    const username = InputSanitizer.sanitizeUsername(rawUsername);
+
+    // 验证 AI 引擎
+    const aiEngine = InputSanitizer.validateAIEngine(rawAiEngine);
+
+    // 验证基准分支
+    const baseBranch = InputSanitizer.validateBranchName(rawBaseBranch);
+
+    // 清理项目路径和仓库 URL
+    let projectPath = rawProjectPath;
+    let repoUrl = rawRepoUrl;
+
+    if (projectPath) {
+      projectPath = InputSanitizer.sanitizeProjectPath(projectPath);
+    }
+
+    if (repoUrl) {
+      repoUrl = InputSanitizer.sanitizeRepoUrl(repoUrl);
+    }
+
+    if (!projectPath && !repoUrl) {
+      ctx.status = 400;
+      ctx.body = {
+        success: false,
+        error: "必须提供 projectPath 或 repoUrl 之一",
+      };
+      return;
+    }
+
+    // 创建异步任务
+    const taskId = taskManager.createTask(requirement, projectPath || repoUrl, {
+      projectPath,
+      repoUrl,
+      runTests,
+      autoPush,
+      aiEngine,
+      baseBranch,
+      createNewBranch,
+      username,
+      mergeToAlpha,
+      mergeToBeta,
+      mergeToMaster,
+      needsApproval,
+    });
+
+    const params = {
+      projectPath,
+      repoUrl,
+      requirement,
+      runTests,
+      autoPush,
+      aiEngine,
+      baseBranch,
+      createNewBranch,
+      username,
+      mergeToAlpha,
+      mergeToBeta,
+      mergeToMaster,
+      needsApproval,
+    };
+
+    // 🔑 使用任务队列（如果启用）或直接执行
+    if (taskQueue) {
+      // 添加到任务队列
+      try {
+        const queueJob = await taskQueue.addTask({
+          taskId,
+          params,
+          priority: 0, // 可以根据需求设置优先级
+        });
+
+        logger.info(`📋 任务已加入队列: ${taskId}`, {
+          taskId,
+          queueJobId: queueJob.id,
+          queueType: queueJob.queueType,
+        });
+
+        ctx.body = {
+          success: true,
+          id: taskId,
+          taskId,
+          message: "任务已加入队列，等待处理",
+          statusUrl: `/api/tasks/${taskId}`,
+          queueInfo: {
+            queueJobId: queueJob.id,
+            queueType: queueJob.queueType,
+          },
+        };
+      } catch (error) {
+        logger.error(`队列添加失败，降级为直接执行: ${error.message}`);
+
+        // 降级为直接执行
+        executeFixTask(taskId, params).catch((err) => {
+          logger.error(`任务 ${taskId} 异步执行出错: ${err.message}`, {
+            taskId,
+            error: err.stack,
+          });
+        });
+
+        ctx.body = {
+          success: true,
+          id: taskId,
+          taskId,
+          message: "任务已创建，正在后台处理（直接执行模式）",
+          statusUrl: `/api/tasks/${taskId}`,
+        };
+      }
+    } else {
+      // 直接在后台异步执行任务
+      executeFixTask(taskId, params).catch((err) => {
+        logger.error(`任务 ${taskId} 异步执行出错: ${err.message}`, {
+          taskId,
+          error: err.stack,
+        });
+      });
+
+      ctx.body = {
+        success: true,
+        id: taskId,
+        taskId,
+        message: "任务已创建，正在后台处理",
+        statusUrl: `/api/tasks/${taskId}`,
+      };
+    }
+  } catch (error) {
+    ctx.status = 400;
+    ctx.body = {
+      success: false,
+      error: error.message,
+    };
+  }
+});
+
+/**
+ * 查询任务状态
+ * GET /api/tasks/:taskId
+ */
+router.get("/api/tasks/:taskId", async (ctx) => {
+  const { taskId } = ctx.params;
+  const task = taskManager.getTask(taskId);
+
+  if (!task) {
+    ctx.status = 404;
+    ctx.body = {
+      success: false,
+      error: "任务不存在",
+    };
+    return;
+  }
+
+  ctx.body = {
+    success: true,
+    task: {
+      ...task,
+      // 添加 taskId 别名(前端使用 taskId 而不是 id)
+      taskId: task.id,
+      // 添加便捷字段
+      isRunning: task.status === "running",
+      isCompleted: task.status === "completed",
+      isFailed: task.status === "failed",
+      isPending: task.status === "pending",
+      isWaitingApproval: task.status === "waiting_approval",
+    },
+  };
+});
+
+/**
+ * 取消任务
+ * POST /api/tasks/:taskId/cancel
+ */
+router.post("/api/tasks/:taskId/cancel", async (ctx) => {
+  try {
+    const { taskId } = ctx.params;
+
+    taskManager.cancelTask(taskId);
+
+    ctx.body = {
+      success: true,
+      message: "任务已取消",
+      taskId,
+    };
+  } catch (error) {
+    ctx.status = 400;
+    ctx.body = {
+      success: false,
+      error: error.message,
+    };
+  }
+});
+
+/**
+ * 查看任务修改内容
+ * GET /api/tasks/:taskId/changes
+ */
+router.get("/api/tasks/:taskId/changes", async (ctx) => {
+  try {
+    const { taskId } = ctx.params;
+    const task = taskManager.getTask(taskId);
+
+    if (!task) {
+      ctx.status = 404;
+      ctx.body = {
+        success: false,
+        error: "任务不存在",
+      };
+      return;
+    }
+
+    // 只有等待确认状态的任务才能查看修改
+    if (task.status !== "waiting_approval") {
+      ctx.status = 400;
+      ctx.body = {
+        success: false,
+        error: `任务状态为 ${task.status}，无法查看修改内容`,
+        hint: "只有等待确认状态的任务才能查看修改",
+      };
+      return;
+    }
+
+    const { fixResult, workingDir, branchName } = task;
+    logger.info(`查看任务 ${taskId} 的修改内容`);
+
+    // 优先使用已保存的 gitDiff 数据
+    if (fixResult?.gitDiff) {
+      logger.info("使用已保存的 gitDiff 数据");
+
+      ctx.body = {
+        success: true,
+        taskId,
+        changes: {
+          fullDiff: fixResult.gitDiff.fullDiff,
+          actualChangedFiles: fixResult.gitDiff.actualChangedFiles,
+          fileChanges: fixResult.gitDiff.fileChanges,
+          untrackedFiles: fixResult.gitDiff.untrackedFiles,
+          summary: fixResult.summary || "",
+          conversationTurns: fixResult.conversationTurns,
+          fullOutput: fixResult.fullOutput,
+        },
+        projectInfo: {
+          workingDir,
+          branchName,
+        },
+        actions: {
+          approve: `/api/tasks/${taskId}/approve`,
+          reject: `/api/tasks/${taskId}/reject`,
+        },
+      };
+      return;
+    }
+
+    // 降级方案: 实时获取 git diff (兼容旧数据或 gitDiff 不存在的情况)
+    logger.info("gitDiff 不存在,实时获取 git diff");
+
+    // 使用 GitService 获取 diff
+    const gitDiffResult = GitService.getWorkspaceDiff(workingDir);
+
+    // 对比 AI 记录的文件和实际变更的文件
+    const recordedFiles = fixResult?.changedFiles || [];
+    const recordedSet = new Set(recordedFiles);
+    const actualSet = new Set(gitDiffResult.actualChangedFiles);
+
+    // 找出 AI 遗漏的文件(实际变更了但没记录)
+    const missedFiles = gitDiffResult.actualChangedFiles.filter(
+      (f) => !recordedSet.has(f)
+    );
+
+    // 找出 AI 多记录的文件(记录了但实际没变更)
+    const extraFiles = recordedFiles.filter((f) => !actualSet.has(f));
+
+    // 为文件添加 isMissed 标记
+    const fileChanges = gitDiffResult.fileChanges.map((fileChange) => ({
+      ...fileChange,
+      isMissed: missedFiles.includes(fileChange.file),
+    }));
+
+    ctx.body = {
+      success: true,
+      taskId,
+      changes: {
+        fullDiff: gitDiffResult.fullDiff, // 完整的 diff
+        actualChangedFiles: gitDiffResult.actualChangedFiles, // 实际变更的文件列表(包括修改+新增)
+        recordedFiles, // AI 记录的文件列表
+        missedFiles, // AI 遗漏的文件
+        extraFiles, // AI 多记录的文件
+        fileChanges, // 每个文件的详细 diff
+        stagedFiles: gitDiffResult.stagedFiles, // 已暂存的文件
+        unstagedFiles: gitDiffResult.unstagedFiles, // 未暂存的文件
+        untrackedFiles: gitDiffResult.untrackedFiles, // 未跟踪的新文件
+        summary: fixResult?.summary || "无摘要信息",
+        conversationTurns: fixResult?.conversationTurns,
+        fullOutput: fixResult?.fullOutput,
+      },
+      projectInfo: {
+        workingDir,
+        branchName,
+      },
+      actions: {
+        approve: `/api/tasks/${taskId}/approve`,
+        reject: `/api/tasks/${taskId}/reject`,
+      },
+    };
+  } catch (error) {
+    ctx.status = 500;
+    ctx.body = {
+      success: false,
+      error: error.message,
+    };
+  }
+});
+
+/**
+ * 确认任务修改并执行 Git 操作
+ * POST /api/tasks/:taskId/approve
+ */
+router.post("/api/tasks/:taskId/approve", async (ctx) => {
+  try {
+    const { taskId } = ctx.params;
+    const task = taskManager.getTask(taskId);
+
+    if (!task) {
+      ctx.status = 404;
+      ctx.body = {
+        success: false,
+        error: "任务不存在",
+      };
+      return;
+    }
+
+    if (task.status !== "waiting_approval") {
+      ctx.status = 400;
+      ctx.body = {
+        success: false,
+        error: `任务状态为 ${task.status}，无法确认`,
+        hint: "只有等待确认状态的任务才能确认",
+      };
+      return;
+    }
+
+    const {
+      fixResult,
+      workingDir,
+      branchName,
+      projectName,
+      aiEngine,
+      pendingGitOperations,
+    } = task;
+
+    if (!fixResult || !workingDir || !pendingGitOperations) {
+      ctx.status = 400;
+      ctx.body = {
+        success: false,
+        error: "任务信息不完整",
+      };
+      return;
+    }
+
+    logger.info(`✅ 开发者确认任务 ${taskId} 的修改，开始执行 Git 操作`, {
+      taskId,
+    });
+
+    // 更新任务状态
+    taskManager.updateProgress(taskId, "running", "开发者已确认，执行 Git 操作");
+
+    if (wsNotifier) {
+      wsNotifier.notifyTaskProgress(
+        taskId,
+        "approved",
+        "开发者已确认修改",
+        55
+      );
+    }
+
+    // 异步执行 Git 操作
+    performGitOperations(
+      taskId,
+      workingDir,
+      branchName,
+      projectName,
+      aiEngine,
+      fixResult,
+      pendingGitOperations
+    ).catch((err) => {
+      logger.error(`任务 ${taskId} Git 操作失败: ${err.message}`, {
+        taskId,
+        error: err.stack,
+      });
+
+      taskManager.failTask(taskId, err);
+
+      if (wsNotifier) {
+        wsNotifier.notifyTaskFailed(taskId, err);
+      }
+
+      // 🔑 Git 操作失败时释放锁
+      if (workingDir) {
+        projectLock.releaseLock(workingDir, taskId);
+        logger.info(`🔓 Git 操作失败，释放项目锁: ${workingDir}`, { taskId });
+      }
+    });
+
+    ctx.body = {
+      success: true,
+      message: "已确认修改，正在执行 Git 操作",
+      taskId,
+      statusUrl: `/api/tasks/${taskId}`,
+    };
+  } catch (error) {
+    ctx.status = 500;
+    ctx.body = {
+      success: false,
+      error: error.message,
+    };
+  }
+});
+
+/**
+ * 拒绝任务修改
+ * POST /api/tasks/:taskId/reject
+ */
+router.post("/api/tasks/:taskId/reject", async (ctx) => {
+  try {
+    const { taskId } = ctx.params;
+    const { reason } = ctx.request.body;
+
+    const task = taskManager.getTask(taskId);
+
+    if (!task) {
+      ctx.status = 404;
+      ctx.body = {
+        success: false,
+        error: "任务不存在",
+      };
+      return;
+    }
+
+    if (task.status !== "waiting_approval") {
+      ctx.status = 400;
+      ctx.body = {
+        success: false,
+        error: `任务状态为 ${task.status}，无法拒绝`,
+        hint: "只有等待确认状态的任务才能拒绝",
+      };
+      return;
+    }
+
+    logger.warn(`❌ 开发者拒绝任务 ${taskId} 的修改`, {
+      taskId,
+      reason: reason || "未提供原因",
+    });
+
+    // 还原代码修改
+    const { workingDir, branchName } = task;
+    let revertResult = { success: false, message: "" };
+
+    if (workingDir) {
+      try {
+        logger.info(`开始还原工作目录 ${workingDir} 的代码修改`);
+
+        // 1. 重置所有已暂存的更改
+        try {
+          ExecUtil.execSync("git reset HEAD .", {
+            cwd: workingDir,
+          });
+          logger.info("已重置暂存区");
+        } catch (err) {
+          logger.warn("重置暂存区失败(可能没有暂存内容):", err.message);
+        }
+
+        // 2. 还原所有已跟踪文件的修改
+        try {
+          ExecUtil.execSync("git checkout .", {
+            cwd: workingDir,
+          });
+          logger.info("已还原所有已跟踪文件的修改");
+        } catch (err) {
+          logger.error("还原文件失败:", err.message);
+          throw err;
+        }
+
+        // 3. 删除所有未跟踪的文件(新增的文件)
+        try {
+          const untrackedFiles = ExecUtil.execSync(
+            "git ls-files --others --exclude-standard",
+            {
+              cwd: workingDir,
+            }
+          )
+            .split("\n")
+            .filter(Boolean);
+
+          if (untrackedFiles.length > 0) {
+            const fs = require("fs");
+            for (const file of untrackedFiles) {
+              const fullPath = path.join(workingDir, file);
+              if (fs.existsSync(fullPath)) {
+                fs.unlinkSync(fullPath);
+                logger.info(`已删除新增文件: ${file}`);
+              }
+            }
+          }
+        } catch (err) {
+          logger.warn("删除未跟踪文件失败:", err.message);
+        }
+
+        // 4. 如果有分支,切换回主分支并删除工作分支
+        if (branchName && branchName !== "main" && branchName !== "master") {
+          try {
+            // 获取默认分支
+            const defaultBranch = ExecUtil.execSync(
+              "git symbolic-ref refs/remotes/origin/HEAD | sed 's@^refs/remotes/origin/@@'",
+              {
+                cwd: workingDir,
+              }
+            ).trim() || "main";
+
+            // 切换到默认分支
+            ExecUtil.execSync(`git checkout ${defaultBranch}`, {
+              cwd: workingDir,
+            });
+
+            // 删除工作分支
+            ExecUtil.execSync(`git branch -D ${branchName}`, {
+              cwd: workingDir,
+            });
+
+            logger.info(`已删除工作分支: ${branchName}`);
+          } catch (err) {
+            logger.warn(`删除分支失败: ${err.message}`);
+          }
+        }
+
+        revertResult = {
+          success: true,
+          message: "代码已成功还原到修改前状态",
+        };
+        logger.info("✅ 代码还原完成");
+      } catch (error) {
+        revertResult = {
+          success: false,
+          message: `代码还原失败: ${error.message}`,
+        };
+        logger.error("❌ 代码还原失败:", error);
+      }
+    }
+
+    // 更新任务状态为失败
+    const error = new Error(
+      `开发者拒绝修改: ${reason || "未提供拒绝原因"}`
+    );
+    taskManager.failTask(taskId, error);
+
+    // WebSocket 通知
+    if (wsNotifier) {
+      wsNotifier.notifyTaskFailed(taskId, error);
+    }
+
+    // 释放项目锁
+    if (workingDir) {
+      projectLock.releaseLock(workingDir, taskId);
+      logger.info(`🔓 拒绝修改，释放项目锁: ${workingDir}`, { taskId });
+    }
+
+    ctx.body = {
+      success: true,
+      message: "已拒绝修改",
+      taskId,
+      reason: reason || "未提供原因",
+      revert: revertResult, // 代码还原结果
+    };
+  } catch (error) {
+    ctx.status = 500;
+    ctx.body = {
+      success: false,
+      error: error.message,
+    };
+  }
+});
+
+/**
+ * 获取所有任务列表
+ * GET /api/tasks
+ *
+ * 查询参数：
+ * - page: 页码，从 1 开始，默认 1
+ * - pageSize: 每页数量，默认 20，最大 100
+ * - status: 任务状态过滤 (pending, running, waiting_approval, completed, failed)
+ * - repoUrl: 仓库地址过滤（支持模糊匹配）
+ * - projectPath: 项目路径过滤（支持模糊匹配）
+ */
+router.get("/api/tasks", async (ctx) => {
+  // 解析分页参数
+  const page = Math.max(1, parseInt(ctx.query.page) || 1);
+  const pageSize = Math.min(100, Math.max(1, parseInt(ctx.query.pageSize) || 20));
+
+  // 解析过滤参数
+  const statusFilter = ctx.query.status; // 可选过滤状态：pending, running, waiting_approval, completed, failed
+  const repoUrlFilter = ctx.query.repoUrl; // 仓库地址过滤
+  const projectPathFilter = ctx.query.projectPath; // 项目路径过滤
+
+  // 获取所有任务
+  let tasks = taskManager.getAllTasks(10000); // 获取足够多的任务用于过滤
+
+  // 应用过滤条件
+  if (statusFilter) {
+    tasks = tasks.filter((task) => task.status === statusFilter);
+  }
+
+  if (repoUrlFilter) {
+    tasks = tasks.filter((task) =>
+      task.repoUrl && task.repoUrl.toLowerCase().includes(repoUrlFilter.toLowerCase())
+    );
+  }
+
+  if (projectPathFilter) {
+    tasks = tasks.filter((task) =>
+      task.projectPath && task.projectPath.toLowerCase().includes(projectPathFilter.toLowerCase())
+    );
+  }
+
+  // 计算分页
+  const total = tasks.length;
+  const totalPages = Math.ceil(total / pageSize);
+  const offset = (page - 1) * pageSize;
+  const paginatedTasks = tasks.slice(offset, offset + pageSize);
+
+  // 统计信息（基于所有任务，不受过滤影响）
+  const allTasks = taskManager.getAllTasks(10000);
+  const stats = {
+    total: allTasks.length,
+    pending: allTasks.filter((t) => t.status === "pending").length,
+    running: allTasks.filter((t) => t.status === "running").length,
+    waiting_approval: allTasks.filter((t) => t.status === "waiting_approval").length,
+    completed: allTasks.filter((t) => t.status === "completed").length,
+    failed: allTasks.filter((t) => t.status === "failed").length,
+  };
+
+  ctx.body = {
+    success: true,
+    // 分页信息
+    pagination: {
+      page,
+      pageSize,
+      total,
+      totalPages,
+      hasNextPage: page < totalPages,
+      hasPrevPage: page > 1,
+    },
+    // 过滤条件
+    filters: {
+      status: statusFilter || null,
+      repoUrl: repoUrlFilter || null,
+      projectPath: projectPathFilter || null,
+    },
+    // 全局统计
+    stats,
+    // 任务列表
+    tasks: paginatedTasks.map((task) => ({
+      ...task,
+      // 添加 taskId 别名(前端使用 taskId 而不是 id)
+      taskId: task.id,
+      // 添加便捷字段
+      isRunning: task.status === "running",
+      isCompleted: task.status === "completed",
+      isFailed: task.status === "failed",
+      isPending: task.status === "pending",
+      isWaitingApproval: task.status === "waiting_approval",
+    })),
+  };
+});
+
+/**
+ * WebSocket 统计信息
+ * GET /api/websocket/stats
+ */
+router.get("/api/websocket/stats", async (ctx) => {
+  if (!wsNotifier) {
+    ctx.body = {
+      success: false,
+      error: "WebSocket 服务未启用",
+      suggestion: "运行 npm run install:ws 安装 WebSocket 支持",
+    };
+    return;
+  }
+
+  ctx.body = {
+    success: true,
+    stats: wsNotifier.getStats(),
+  };
+});
+
+/**
+ * 任务队列统计信息
+ * GET /api/queue/stats
+ */
+router.get("/api/queue/stats", async (ctx) => {
+  if (!taskQueue) {
+    ctx.body = {
+      success: false,
+      error: "任务队列未启用",
+      message: "当前使用直接执行模式",
+    };
+    return;
+  }
+
+  try {
+    const stats = await taskQueue.getStats();
+    ctx.body = {
+      success: true,
+      stats,
+    };
+  } catch (error) {
+    ctx.status = 500;
+    ctx.body = {
+      success: false,
+      error: error.message,
+    };
+  }
+});
+
+/**
+ * 项目锁统计信息
+ * GET /api/project-locks/stats
+ */
+router.get("/api/project-locks/stats", async (ctx) => {
+  try {
+    const stats = projectLock.getStats();
+    ctx.body = {
+      success: true,
+      stats,
+    };
+  } catch (error) {
+    ctx.status = 500;
+    ctx.body = {
+      success: false,
+      error: error.message,
+    };
+  }
+});
+
+/**
+ * 测试接口 - 简单的本地文件修改测试
+ * POST /api/test
+ */
+router.post("/api/test", async (ctx) => {
+  try {
+    const {
+      projectPath: rawProjectPath,
+      requirement: rawRequirement,
+      aiEngine: rawAiEngine,
+    } = ctx.request.body;
+
+    if (!rawProjectPath || !rawRequirement) {
+      ctx.status = 400;
+      ctx.body = {
+        success: false,
+        error: "缺少必填参数: projectPath 和 requirement",
+      };
+      return;
+    }
+
+    // 清理和验证输入
+    const projectPath = InputSanitizer.sanitizeProjectPath(rawProjectPath);
+    const requirement = InputSanitizer.sanitizeRequirement(rawRequirement);
+    const aiEngine = InputSanitizer.validateAIEngine(rawAiEngine);
+
+    // 选择 AI 引擎
+    const { service: aiService, name: aiName } = getAIService(aiEngine);
+
+    logger.info(`🧪 测试模式: 仅执行 ${aiName} 修复，不进行 Git 操作`);
+
+    const result = await aiService.fixCode(projectPath, requirement);
+
+    ctx.body = result;
+  } catch (error) {
+    ctx.status = 400;
+    ctx.body = {
+      success: false,
+      error: error.message,
+    };
+  }
+});
+
+// 注册路由
+app.use(router.routes());
+app.use(router.allowedMethods());
+
+// 启动服务
+const server = app.listen(config.get("server.port"), () => {
+  logger.info("=".repeat(60));
+  logger.info("🚀 AI 自动修复服务已启动 (Koa 框架)");
+  logger.info("=".repeat(60));
+  logger.info(`📍 服务地址: http://localhost:${config.get("server.port")}`);
+  logger.info(`📂 工作目录: ${config.get("server.workDir")}`);
+
+  // 初始化 WebSocket 服务
+  if (wsNotifier) {
+    try {
+      wsNotifier.initialize(server);
+      logger.info(
+        `📡 WebSocket 服务已启动: ws://localhost:${config.get(
+          "server.port"
+        )}/ws`
+      );
+    } catch (error) {
+      logger.error("❌ WebSocket 服务初始化失败:", error);
+    }
+  }
+
+  // 显示任务队列信息
+  if (taskQueue) {
+    taskQueue
+      .getStats()
+      .then((stats) => {
+        logger.info(`📋 任务队列已启用: ${stats.queueType}`);
+        if (stats.queueType === "redis") {
+          logger.info(`   - Redis 队列`);
+        } else {
+          logger.info(`   - 本地队列（最大并发: ${stats.maxConcurrent}）`);
+        }
+        logger.info(`   - 等待中: ${stats.waiting}`);
+        logger.info(`   - 执行中: ${stats.active}`);
+      })
+      .catch((err) => {
+        logger.warn("获取队列统计失败:", err.message);
+      });
+  } else {
+    logger.info("📋 任务队列未启用（直接执行模式）");
+  }
+
+  // 显示项目锁信息
+  logger.info("🔒 项目锁管理器已启用");
+  logger.info("   - 防止同一项目的并发 Git 冲突");
+  logger.info("   - 不同项目可并行执行");
+
+  logger.info(`🤖 默认 AI 引擎: Claude CLI`);
+
+  logger.info(`支持的引擎:`);
+  logger.info(`   - claude-cli: Claude CLI (推荐，使用 claude -p 命令)`);
+  logger.info(
+    `📢 企微通知: ${
+      config.get("notification.wecomWebhook") ? "已配置" : "未配置"
+    }`
+  );
+  logger.info(
+    `🔐 API 认证: ${config.get("security.apiKey") ? "已启用" : "未启用"}`
+  );
+
+  logger.info("=".repeat(60));
+  logger.info("可用接口:");
+  logger.info("  GET  /health                      - 健康检查（含性能指标）");
+  logger.info("  GET  /api/metrics                 - 性能监控指标");
+  logger.info("  GET  /api/config                  - 配置信息（需认证）");
+  logger.info(
+    "  POST /api/fix-bug                 - 异步修复（推荐，立即返回任务ID）"
+  );
+  logger.info("  GET  /api/tasks/:taskId           - 查询任务状态");
+  logger.info("  GET  /api/tasks/:taskId/changes   - 查看任务修改内容（需等待确认）");
+  logger.info("  POST /api/tasks/:taskId/approve   - 确认任务修改并执行 Git 操作");
+  logger.info("  POST /api/tasks/:taskId/reject    - 拒绝任务修改");
+  logger.info("  POST /api/tasks/:taskId/cancel    - 取消任务");
+  logger.info("  GET  /api/tasks                   - 获取任务列表");
+  logger.info("  GET  /api/queue/stats             - 任务队列统计");
+  logger.info("  GET  /api/project-locks/stats     - 项目锁统计");
+  logger.info("  GET  /api/websocket/stats         - WebSocket 统计");
+  logger.info("  POST /api/test                    - 测试修复（仅 AI，同步）");
+
+  logger.info("=".repeat(60));
+  logger.info("💡 新功能提示:");
+  logger.info("  - ✅ 请求追踪：每个请求自动分配唯一 ID");
+  logger.info("  - ✅ 性能监控：实时收集任务执行指标");
+  logger.info("  - ✅ 配置管理：集中化配置验证和访问");
+  logger.info("  - ✅ 分支冲突检测：自动处理分支名称冲突");
+  logger.info("  - ✅ Git 分支验证：确保分支名称符合规范");
+  logger.info("  - ✅ 人工确认机制：AI 修复后需开发者确认才执行 Git 操作");
+
+  logger.info("=".repeat(60));
+  logger.info("🔒 安全功能:");
+  logger.info("  - API Key 认证（通过 X-API-Key 请求头）");
+  logger.info("  - IP 白名单（通过 ALLOWED_IPS 环境变量配置）");
+  logger.info("  - 请求频率限制（10s 30 次，敏感接口 1小时 20 次）");
+  logger.info("  - 输入验证和清理（防止注入攻击）");
+});
+
+// 优雅关闭
+const gracefulShutdown = async (signal) => {
+  logger.info(`👋 收到 ${signal} 信号，正在优雅退出...`);
+
+  // 关闭任务队列
+  if (taskQueue) {
+    try {
+      logger.info("📋 关闭任务队列...");
+      await taskQueue.close();
+      logger.info("✅ 任务队列已关闭");
+    } catch (error) {
+      logger.error("❌ 关闭任务队列失败:", error);
+    }
+  }
+
+  // 关闭 WebSocket 服务
+  if (wsNotifier) {
+    logger.info("📡 关闭 WebSocket 服务...");
+    wsNotifier.close();
+  }
+
+  server.close(() => {
+    logger.info("✅ 服务器已关闭");
+    process.exit(0);
+  });
+
+  // 如果 10 秒后还没关闭，强制退出
+  setTimeout(() => {
+    logger.error("⚠️ 强制退出");
+    process.exit(1);
+  }, 10000);
+};
+
+process.on("SIGTERM", () => gracefulShutdown("SIGTERM"));
+process.on("SIGINT", () => gracefulShutdown("SIGINT"));