aico-cli 0.4.2 → 0.4.5

package/dist/chunks/run-command.mjs

@@ -0,0 +1,47 @@
+import { p as processManager } from '../cli.mjs';
+import 'cac';
+import 'ansis';
+import './simple-config.mjs';
+import 'inquirer';
+import 'tinyexec';
+import 'node:os';
+import 'node:fs';
+import 'node:child_process';
+import 'node:util';
+import 'child_process';
+import 'util';
+import 'ora';
+import 'dayjs';
+import 'node:path';
+import 'pathe';
+import 'node:url';
+import 'node:events';
+
+async function run(command) {
+  try {
+    const parts = command.split(" ").filter((part) => part.trim());
+    if (parts.length === 0) {
+      throw new Error("\u547D\u4EE4\u4E0D\u80FD\u4E3A\u7A7A");
+    }
+    const cmd = parts[0];
+    const args = parts.slice(1);
+    const result = await processManager.spawn(cmd, args, {
+      name: cmd,
+      timeout: 6e4,
+      // 60秒超时
+      stdio: "pipe"
+    });
+    return {
+      stdout: result.stdout || "",
+      stderr: result.stderr || ""
+    };
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(`Command failed: ${command}
+Error: ${error.message}`);
+    }
+    throw error;
+  }
+}
+
+export { run };

package/dist/chunks/simple-config.mjs

@@ -13,7 +13,7 @@ import { join as join$1 } from 'node:path';
 import { join, dirname, basename } from 'pathe';
 import { fileURLToPath } from 'node:url';
 
-const version = "0.4.2";
+const version = "0.4.5";
 
 function displayBanner(subtitle) {
   const defaultSubtitle = "\u4E00\u952E\u914D\u7F6E\u4F60\u7684\u5F00\u53D1\u73AF\u5883";

package/dist/cli.mjs

@@ -4,6 +4,7 @@ import ansis from 'ansis';
 import { N as createEscapablePrompt, O as displayBannerWithInfo, a as init, P as executeWithEscapeSupport, Q as handleExitPromptError, R as handleGeneralError, T as EscapeKeyPressed, U as displayBanner, V as ConfigCheckerInstaller, W as updateAicoConfig, X as version, Y as InstallationComposer, Z as readAicoConfig } from './chunks/simple-config.mjs';
 import inquirer$1 from 'inquirer';
 import { spawn, exec as exec$1 } from 'node:child_process';
+import { EventEmitter } from 'node:events';
 import 'tinyexec';
 import 'node:os';
 import 'node:fs';
@@ -22,25 +23,538 @@ const inquirer = {
   createPromptModule: inquirer$1.createPromptModule
 };
 
-async function getCurrentVersion() {
-  try {
-    return new Promise((resolve) => {
-      const child = spawn("npm", ["list", "-g", "aico-cli", "--depth=0"], {
-        stdio: "pipe",
-        shell: process.platform === "win32"
+class ProcessManager extends EventEmitter {
+  processes = /* @__PURE__ */ new Map();
+  isShuttingDown = false;
+  constructor() {
+    super();
+    this.setupSignalHandlers();
+  }
+  /**
+   * 设置信号处理器
+   */
+  setupSignalHandlers() {
+    process.on("SIGINT", () => {
+      this.shutdown("SIGINT");
+    });
+    process.on("SIGTERM", () => {
+      this.shutdown("SIGTERM");
+    });
+    process.on("beforeExit", () => {
+      this.cleanup();
+    });
+    process.on("exit", () => {
+      this.cleanup();
+    });
+  }
+  /**
+   * 启动进程
+   */
+  async spawn(command, args = [], options = {}) {
+    const startTime = Date.now();
+    const processName = options.name || command;
+    const isWindows = process.platform === "win32";
+    this.log(`\u542F\u52A8\u8FDB\u7A0B: ${processName}`, "info");
+    try {
+      let finalCommand = command;
+      let finalArgs = args;
+      if (isWindows) {
+        if (command === "npx") {
+          finalCommand = "npx.cmd";
+        } else if (command === "claude") {
+          finalCommand = "claude.cmd";
+        }
+      }
+      const child = spawn(finalCommand, finalArgs, {
+        cwd: options.cwd || process.cwd(),
+        env: { ...process.env, ...options.env },
+        stdio: options.stdio || "pipe",
+        shell: false,
+        // 禁用shell模式，避免进程泄漏
+        windowsHide: isWindows
+        // Windows上隐藏子进程窗口
       });
-      let output = "";
-      child.stdout?.on("data", (data) => {
-        output += data.toString();
+      this.registerProcess(child, processName);
+      let timeoutId;
+      let isTimeout = false;
+      if (options.timeout) {
+        timeoutId = setTimeout(() => {
+          isTimeout = true;
+          this.log(`\u8FDB\u7A0B ${processName} \u8D85\u65F6\uFF0C\u6B63\u5728\u7EC8\u6B62...`, "warning");
+          child.kill("SIGTERM");
+          setTimeout(() => {
+            if (child.pid && !child.killed) {
+              child.kill("SIGKILL");
+            }
+          }, 1e3);
+        }, options.timeout);
+      }
+      let stdout = "";
+      let stderr = "";
+      if (child.stdout) {
+        child.stdout.on("data", (data) => {
+          stdout += data.toString();
+        });
+      }
+      if (child.stderr) {
+        child.stderr.on("data", (data) => {
+          stderr += data.toString();
+        });
+      }
+      const exitCode = await new Promise((resolve, reject) => {
+        child.on("close", (code) => {
+          if (timeoutId) clearTimeout(timeoutId);
+          this.unregisterProcess(child.pid);
+          resolve(code ?? 0);
+        });
+        child.on("error", (error) => {
+          if (timeoutId) clearTimeout(timeoutId);
+          this.unregisterProcess(child.pid);
+          reject(error);
+        });
       });
-      child.on("close", () => {
-        const match = output.match(/aico-cli@(\d+\.\d+\.\d+)/);
-        resolve(match ? match[1] : null);
+      const duration = Date.now() - startTime;
+      const success = exitCode === 0 && !isTimeout;
+      this.log(
+        `\u8FDB\u7A0B ${processName} \u6267\u884C${success ? "\u6210\u529F" : "\u5931\u8D25"} (${duration}ms)`,
+        success ? "success" : "error"
+      );
+      return {
+        exitCode,
+        stdout: stdout || void 0,
+        stderr: stderr || void 0,
+        success,
+        duration
+      };
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      this.log(`\u8FDB\u7A0B ${processName} \u6267\u884C\u5931\u8D25: ${error}`, "error");
+      return {
+        exitCode: 1,
+        stderr: error instanceof Error ? error.message : String(error),
+        success: false,
+        duration
+      };
+    }
+  }
+  /**
+   * 注册进程
+   */
+  registerProcess(child, name) {
+    if (!child.pid) {
+      this.log(`\u65E0\u6CD5\u6CE8\u518C\u8FDB\u7A0B ${name}: \u6CA1\u6709PID`, "error");
+      return;
+    }
+    if (this.processes.has(child.pid)) {
+      this.log(`\u8FDB\u7A0B ${name} (PID: ${child.pid}) \u5DF2\u7ECF\u6CE8\u518C\u8FC7`, "warning");
+      return;
+    }
+    const processInfo = {
+      pid: child.pid,
+      name,
+      startTime: /* @__PURE__ */ new Date(),
+      status: "running",
+      process: child
+    };
+    this.processes.set(child.pid, processInfo);
+    let isCleanedUp = false;
+    const cleanup = () => {
+      if (!isCleanedUp) {
+        isCleanedUp = true;
+        this.unregisterProcess(child.pid);
+      }
+    };
+    child.on("close", (code) => {
+      const info = this.processes.get(child.pid);
+      if (info && !isCleanedUp) {
+        info.status = code === 0 ? "completed" : "failed";
+        info.exitCode = code ?? void 0;
+        this.log(`\u8FDB\u7A0B ${name} (PID: ${child.pid}) \u5DF2\u5173\u95ED\uFF0C\u9000\u51FA\u7801: ${code}`, "info");
+      }
+      cleanup();
+    });
+    child.on("error", (error) => {
+      const info = this.processes.get(child.pid);
+      if (info && !isCleanedUp) {
+        info.status = "failed";
+        this.log(`\u8FDB\u7A0B ${name} (PID: ${child.pid}) \u53D1\u751F\u9519\u8BEF: ${error}`, "error");
+      }
+      cleanup();
+    });
+  }
+  /**
+   * 注销进程
+   */
+  unregisterProcess(pid) {
+    const info = this.processes.get(pid);
+    if (info) {
+      this.log(`\u6CE8\u9500\u8FDB\u7A0B: ${info.name} (PID: ${pid})`, "info");
+      this.processes.delete(pid);
+    } else {
+      this.log(`\u5C1D\u8BD5\u6CE8\u9500\u4E0D\u5B58\u5728\u7684\u8FDB\u7A0B (PID: ${pid})`, "warning");
+    }
+  }
+  /**
+   * 公开的注销进程方法（用于测试）
+   */
+  unregisterProcessForTesting(pid) {
+    this.unregisterProcess(pid);
+  }
+  /**
+   * 优雅关闭
+   */
+  async shutdown(signal) {
+    if (this.isShuttingDown) return;
+    this.isShuttingDown = true;
+    this.log(`\u6B63\u5728\u5173\u95ED ${this.processes.size} \u4E2A\u8FDB\u7A0B...`, "warning");
+    const firstSignalTime = Date.now();
+    let forceShutdownRequested = false;
+    const forceShutdownHandler = () => {
+      forceShutdownRequested = true;
+      this.log("\u7528\u6237\u8BF7\u6C42\u5F3A\u5236\u5173\u95ED\uFF0C\u7ACB\u5373\u7EC8\u6B62\u6240\u6709\u8FDB\u7A0B...", "warning");
+    };
+    process.once("SIGINT", forceShutdownHandler);
+    let runningProcesses = Array.from(this.processes.values()).filter((p) => p.status === "running");
+    if (runningProcesses.length > 0) {
+      this.log(`\u5411 ${runningProcesses.length} \u4E2A\u8FD0\u884C\u4E2D\u7684\u8FDB\u7A0B\u53D1\u9001SIGTERM\u4FE1\u53F7...`, "info");
+      for (const info of runningProcesses) {
+        try {
+          info.process.kill("SIGTERM");
+          info.status = "killed";
+        } catch (error) {
+          this.log(`\u65E0\u6CD5\u7EC8\u6B62\u8FDB\u7A0B ${info.name} (PID: ${info.pid}): ${error}`, "error");
+        }
+      }
+      const maxWaitTime = 1e3;
+      const checkInterval = 100;
+      let waitedTime = 0;
+      while (waitedTime < maxWaitTime && !forceShutdownRequested) {
+        await new Promise((resolve) => setTimeout(resolve, checkInterval));
+        waitedTime += checkInterval;
+        runningProcesses = Array.from(this.processes.values()).filter((p) => p.status === "running");
+        if (runningProcesses.length === 0) {
+          break;
+        }
+      }
+    }
+    process.removeListener("SIGINT", forceShutdownHandler);
+    runningProcesses = Array.from(this.processes.values()).filter((p) => p.status === "running");
+    if (runningProcesses.length > 0) {
+      this.log(`\u5F3A\u5236\u7EC8\u6B62 ${runningProcesses.length} \u4E2A\u4ECD\u5728\u8FD0\u884C\u7684\u8FDB\u7A0B...`, "warning");
+      for (const info of runningProcesses) {
+        try {
+          info.process.kill("SIGKILL");
+          this.log(`\u5F3A\u5236\u7EC8\u6B62\u8FDB\u7A0B ${info.name} (PID: ${info.pid})`, "warning");
+        } catch (error) {
+          this.log(`\u65E0\u6CD5\u5F3A\u5236\u7EC8\u6B62\u8FDB\u7A0B ${info.name} (PID: ${info.pid}): ${error}`, "error");
+        }
+      }
+    }
+    const totalTime = Date.now() - firstSignalTime;
+    this.log(`\u5173\u95ED\u5B8C\u6210\uFF0C\u8017\u65F6 ${totalTime}ms`, "success");
+    this.cleanup();
+    process.exit(0);
+  }
+  /**
+   * 清理所有进程
+   */
+  cleanup() {
+    const isWindows = process.platform === "win32";
+    if (isWindows) {
+      this.cleanupWindowsProcesses();
+    }
+    for (const [pid, info] of this.processes) {
+      if (info.status === "running") {
+        try {
+          const signal = isWindows ? "SIGTERM" : "SIGKILL";
+          info.process.kill(signal);
+        } catch {
+        }
+      }
+    }
+    this.cleanupZombieProcesses();
+    this.processes.clear();
+  }
+  /**
+   * 获取当前运行的进程数量
+   */
+  getProcessCount() {
+    return this.processes.size;
+  }
+  /**
+   * 获取运行中的进程数量
+   */
+  getRunningProcessCount() {
+    return Array.from(this.processes.values()).filter((p) => p.status === "running").length;
+  }
+  /**
+   * 获取进程列表
+   */
+  getProcessList() {
+    return Array.from(this.processes.values());
+  }
+  /**
+   * 获取运行中的进程列表
+   */
+  getRunningProcessList() {
+    return Array.from(this.processes.values()).filter((p) => p.status === "running");
+  }
+  /**
+   * 检查是否存在进程泄漏（运行中的进程过多）
+   */
+  checkForProcessLeaks(maxAllowed = 10) {
+    const runningCount = this.getRunningProcessCount();
+    if (runningCount > maxAllowed) {
+      this.log(`\u68C0\u6D4B\u5230\u53EF\u80FD\u7684\u8FDB\u7A0B\u6CC4\u6F0F: ${runningCount} \u4E2A\u8FD0\u884C\u4E2D\u7684\u8FDB\u7A0B (\u8D85\u8FC7\u9650\u5236 ${maxAllowed})`, "warning");
+      return true;
+    }
+    return false;
+  }
+  /**
+   * 获取进程管理器状态报告
+   */
+  getStatusReport() {
+    const total = this.getProcessCount();
+    const running = this.getRunningProcessCount();
+    const completed = Array.from(this.processes.values()).filter((p) => p.status === "completed").length;
+    const failed = Array.from(this.processes.values()).filter((p) => p.status === "failed").length;
+    const killed = Array.from(this.processes.values()).filter((p) => p.status === "killed").length;
+    let report = `\u8FDB\u7A0B\u7BA1\u7406\u5668\u72B6\u6001\u62A5\u544A
+`;
+    report += `==================
+`;
+    report += `\u603B\u8FDB\u7A0B\u6570: ${total}
+`;
+    report += `\u8FD0\u884C\u4E2D: ${running}
+`;
+    report += `\u5DF2\u5B8C\u6210: ${completed}
+`;
+    report += `\u5931\u8D25: ${failed}
+`;
+    report += `\u5DF2\u7EC8\u6B62: ${killed}
+`;
+    report += `\u5173\u95ED\u72B6\u6001: ${this.isShuttingDown ? "\u6B63\u5728\u5173\u95ED" : "\u6B63\u5E38\u8FD0\u884C"}
+`;
+    if (running > 0) {
+      report += `
+\u8FD0\u884C\u4E2D\u7684\u8FDB\u7A0B:
+`;
+      this.getRunningProcessList().forEach((process2) => {
+        const duration = Date.now() - process2.startTime.getTime();
+        const durationSeconds = Math.floor(duration / 1e3);
+        report += `  - ${process2.name} (PID: ${process2.pid}) - \u8FD0\u884C\u65F6\u95F4: ${durationSeconds}s
+`;
       });
-      child.on("error", () => {
-        resolve(null);
+    }
+    return report;
+  }
+  /**
+   * 强制清理僵尸进程（状态为运行中但实际已退出的进程）
+   */
+  cleanupZombieProcesses() {
+    let cleanedCount = 0;
+    const runningProcesses = this.getRunningProcessList();
+    const isWindows = process.platform === "win32";
+    this.log(`\u5F00\u59CB\u6E05\u7406\u50F5\u5C38\u8FDB\u7A0B\uFF0C\u5F53\u524D\u8FD0\u884C\u4E2D\u8FDB\u7A0B\u6570: ${runningProcesses.length}`, "info");
+    for (const process2 of runningProcesses) {
+      try {
+        process2.process.kill(0);
+        if (isWindows) {
+          if (process2.process.exitCode !== null) {
+            this.log(`\u6E05\u7406Windows\u50F5\u5C38\u8FDB\u7A0B: ${process2.name} (PID: ${process2.pid})`, "warning");
+            this.unregisterProcess(process2.pid);
+            cleanedCount++;
+          }
+        }
+      } catch (error) {
+        this.log(`\u6E05\u7406\u50F5\u5C38\u8FDB\u7A0B: ${process2.name} (PID: ${process2.pid})`, "warning");
+        this.unregisterProcess(process2.pid);
+        cleanedCount++;
+      }
+    }
+    if (cleanedCount > 0) {
+      this.log(`\u6E05\u7406\u4E86 ${cleanedCount} \u4E2A\u50F5\u5C38\u8FDB\u7A0B`, "info");
+    }
+    return cleanedCount;
+  }
+  /**
+   * 深度清理进程，包括可能的残留进程
+   */
+  deepCleanup() {
+    const isWindows = process.platform === "win32";
+    let totalCleaned = 0;
+    this.log("\u5F00\u59CB\u6DF1\u5EA6\u6E05\u7406\u8FDB\u7A0B...", "info");
+    totalCleaned += this.cleanupZombieProcesses();
+    if (isWindows) {
+      totalCleaned += this.cleanupWindowsProcesses();
+    }
+    const remainingProcesses = this.getProcessCount();
+    if (remainingProcesses > 0) {
+      this.log(`\u5F3A\u5236\u6E05\u7406\u5269\u4F59\u7684 ${remainingProcesses} \u4E2A\u8FDB\u7A0B`, "warning");
+      this.cleanup();
+      totalCleaned += remainingProcesses;
+    }
+    this.log(`\u6DF1\u5EA6\u6E05\u7406\u5B8C\u6210\uFF0C\u603B\u5171\u6E05\u7406\u4E86 ${totalCleaned} \u4E2A\u8FDB\u7A0B`, "info");
+    return totalCleaned;
+  }
+  /**
+   * Windows平台特定的进程清理
+   * 针对Windows的进程管理特点进行优化
+   */
+  cleanupWindowsProcesses() {
+    const isWindows = process.platform === "win32";
+    if (!isWindows) {
+      return 0;
+    }
+    let cleanedCount = 0;
+    const runningProcesses = this.getRunningProcessList();
+    this.log("\u6267\u884CWindows\u5E73\u53F0\u7279\u5B9A\u8FDB\u7A0B\u6E05\u7406...", "info");
+    for (const process2 of runningProcesses) {
+      try {
+        if (process2.process.exitCode !== null) {
+          this.log(`\u6E05\u7406Windows\u8FDB\u7A0B: ${process2.name} (PID: ${process2.pid})`, "warning");
+          this.unregisterProcess(process2.pid);
+          cleanedCount++;
+        }
+      } catch (error) {
+        this.log(`\u5F3A\u5236\u6E05\u7406Windows\u8FDB\u7A0B: ${process2.name} (PID: ${process2.pid})`, "error");
+        this.unregisterProcess(process2.pid);
+        cleanedCount++;
+      }
+    }
+    if (cleanedCount > 0) {
+      this.log(`Windows\u5E73\u53F0\u6E05\u7406\u4E86 ${cleanedCount} \u4E2A\u8FDB\u7A0B`, "info");
+    }
+    return cleanedCount;
+  }
+  /**
+   * 添加进程到列表（用于测试）
+   */
+  addProcessForTesting(processInfo) {
+    this.processes.set(processInfo.pid, processInfo);
+  }
+  /**
+   * 替换当前进程（exec 模式）
+   * 这个方法会完全替换当前进程，不会返回
+   */
+  async replaceProcess(command, args = [], options = {}) {
+    const processName = options.name || command;
+    const isWindows = process.platform === "win32";
+    try {
+      this.cleanup();
+      const { spawn: spawn2 } = await import('node:child_process');
+      let finalCommand = command;
+      let finalArgs = args;
+      if (isWindows) {
+        if (command === "npx") {
+          finalCommand = "npx.cmd";
+        } else if (command === "claude") {
+          finalCommand = "claude.cmd";
+        }
+      }
+      const child = spawn2(finalCommand, finalArgs, {
+        stdio: "inherit",
+        // 继承所有 stdio
+        cwd: options.cwd || process.cwd(),
+        env: { ...process.env, ...options.env },
+        shell: false,
+        // 禁用shell模式，避免进程泄漏
+        // Windows上使用更严格的进程控制
+        windowsHide: isWindows
+        // Windows上隐藏子进程窗口
+      });
+      child.on("error", (error) => {
+        this.log(`\u8FDB\u7A0B\u66FF\u6362\u5931\u8D25: ${error}`, "error");
+        this.cleanup();
+        process.exit(1);
+      });
+      child.on("exit", (code) => {
+        this.log(`\u66FF\u6362\u8FDB\u7A0B\u5DF2\u9000\u51FA\uFF0C\u9000\u51FA\u7801: ${code}`, "info");
+        this.cleanup();
+        process.exit(code || 0);
       });
+      this.registerProcess(child, processName);
+      if (isWindows) {
+        const checkInterval = setInterval(() => {
+          if (child.exitCode !== null) {
+            clearInterval(checkInterval);
+            this.cleanup();
+            process.exit(child.exitCode || 0);
+          }
+        }, 1e3);
+        child.on("exit", () => {
+          clearInterval(checkInterval);
+        });
+      }
+      await new Promise(() => {
+      });
+      process.exit(0);
+    } catch (error) {
+      this.log(`\u8FDB\u7A0B\u66FF\u6362\u5931\u8D25: ${error}`, "error");
+      this.cleanup();
+      process.exit(1);
+    }
+  }
+  /**
+   * 终止特定进程
+   */
+  killProcess(pid, signal = "SIGTERM") {
+    const info = this.processes.get(pid);
+    if (info && info.status === "running") {
+      try {
+        info.process.kill(signal);
+        info.status = "killed";
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    return false;
+  }
+  /**
+   * 日志输出
+   */
+  log(message, level = "info") {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const prefix = `[${timestamp}] [ProcessManager]`;
+    switch (level) {
+      case "info":
+        console.log(ansis.gray(`${prefix} ${message}`));
+        break;
+      case "warning":
+        console.log(ansis.yellow(`${prefix} ${message}`));
+        break;
+      case "error":
+        console.error(ansis.red(`${prefix} ${message}`));
+        break;
+      case "success":
+        console.log(ansis.green(`${prefix} ${message}`));
+        break;
+    }
+  }
+}
+const processManager = new ProcessManager();
+
+const processManager$1 = {
+  __proto__: null,
+  ProcessManager: ProcessManager,
+  processManager: processManager
+};
+
+async function getCurrentVersion() {
+  try {
+    const result = await processManager.spawn("npm", ["list", "-g", "aico-cli", "--depth=0"], {
+      name: "npm list",
+      stdio: "pipe",
+      shell: process.platform === "win32",
+      timeout: 1e4
+      // 10秒超时
     });
+    if (result.success && result.stdout) {
+      const match = result.stdout.match(/aico-cli@(\d+\.\d+\.\d+)/);
+      return match ? match[1] : null;
+    }
+    return null;
   } catch {
     return null;
   }
@@ -55,48 +569,22 @@ async function updateAicoCli() {
       console.log(ansis.gray(`\u{1F4E6} \u5F53\u524D\u7248\u672C: ${currentVersion}`));
     }
     console.log(ansis.cyan("\u23F3 \u6B63\u5728\u6267\u884C\u81EA\u52A8\u66F4\u65B0..."));
-    const isWindows = process.platform === "win32";
-    const child = spawn("npm", ["install", "-g", "aico-cli"], {
+    const result = await processManager.spawn("npm", ["install", "-g", "aico-cli"], {
+      name: "npm install",
       stdio: "inherit",
       // 继承父进程的 stdio，显示安装进度
-      cwd: process.cwd(),
-      shell: isWindows
-      // Windows 上使用 shell
-    });
-    const timeout = setTimeout(() => {
-      console.log(ansis.yellow("\n\u26A0\uFE0F  \u66F4\u65B0\u65F6\u95F4\u8F83\u957F\uFF0C\u53EF\u80FD\u9047\u5230\u7F51\u7EDC\u95EE\u9898"));
-      console.log(ansis.cyan("\u{1F4A1} \u5EFA\u8BAE\u6309 Ctrl+C \u53D6\u6D88\uFF0C\u7136\u540E\u624B\u52A8\u6267\u884C:"));
-      console.log(ansis.white("   npm install -g aico-cli"));
-    }, 15e3);
-    await new Promise((resolve, reject) => {
-      child.on("close", (code) => {
-        clearTimeout(timeout);
-        if (code === 0) {
-          console.log(ansis.green("\n\u2705 aico-cli \u66F4\u65B0\u5B8C\u6210"));
-          resolve();
-        } else {
-          reject(new Error(`npm \u8FDB\u7A0B\u9000\u51FA\uFF0C\u9000\u51FA\u7801: ${code}`));
-        }
-      });
-      child.on("error", (error) => {
-        clearTimeout(timeout);
-        reject(error);
-      });
-      const handleInterrupt = () => {
-        clearTimeout(timeout);
-        child.kill("SIGINT");
-        console.log(ansis.yellow("\n\n\u26A0\uFE0F  \u66F4\u65B0\u5DF2\u53D6\u6D88"));
-        console.log(ansis.cyan("\u{1F4A1} \u8BF7\u624B\u52A8\u6267\u884C: npm install -g aico-cli"));
-        process.exit(0);
-      };
-      process.once("SIGINT", handleInterrupt);
-      child.on("close", () => {
-        process.removeListener("SIGINT", handleInterrupt);
-      });
+      timeout: 3e5,
+      // 5分钟超时（npm安装可能较慢）
+      signalHandling: "graceful"
     });
+    if (result.success) {
+      console.log(ansis.green("\n\u2705 aico-cli \u66F4\u65B0\u5B8C\u6210"));
+    } else {
+      throw new Error(`npm \u8FDB\u7A0B\u9000\u51FA\uFF0C\u9000\u51FA\u7801: ${result.exitCode}`);
+    }
   } catch (error) {
     console.error(ansis.red("\u274C \u66F4\u65B0 aico-cli \u5931\u8D25:"));
-    if (error.code === "ENOENT") {
+    if (error.code === "ENOENT" || error.message?.includes("ENOENT")) {
       console.error(ansis.yellow("\u{1F4A1} \u8BF7\u786E\u4FDD\u5DF2\u5B89\u88C5 npm"));
       console.error(
         ansis.gray("   \u8BF7\u8BBF\u95EE https://nodejs.org/ \u4E0B\u8F7D\u5E76\u5B89\u88C5 Node.js")
@@ -106,6 +594,7 @@ async function updateAicoCli() {
     }
     console.error(ansis.cyan("\n\u{1F4A1} \u6216\u8005\u8BF7\u590D\u5236\u4EE5\u4E0B\u547D\u4EE4\u5728\u547D\u4EE4\u884C\u4E2D\u624B\u52A8\u6267\u884C:"));
     console.error(ansis.white("   npm install -g aico-cli"));
+    processManager.cleanup();
     throw error;
   }
 }
@@ -116,39 +605,15 @@ promisify$1(exec$1);
 
 promisify$1(exec$1);
 
-const execAsync = promisify(exec);
-async function run(command) {
-  try {
-    const result = await execAsync(command);
-    return result;
-  } catch (error) {
-    if (error instanceof Error) {
-      throw new Error(`Command failed: ${command}
-Error: ${error.message}`);
-    }
-    throw error;
-  }
-}
-
-const runCommand = {
-  __proto__: null,
-  run: run
-};
-
 async function tryStartClaude(command, args, options) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(command, args, options);
-    child.on("close", (code) => {
-      if (code === 0) {
-        console.log(ansis.green("\u2705 \u4EE3\u7801\u7F16\u8F91\u5668\u5DF2\u9000\u51FA"));
-        resolve();
-      } else {
-        reject(new Error(`Claude \u8FDB\u7A0B\u9000\u51FA\uFF0C\u9000\u51FA\u7801: ${code}`));
-      }
-    });
-    child.on("error", (error) => {
-      reject(error);
-    });
+  const isWindows = process.platform === "win32";
+  await processManager.replaceProcess(command, args, {
+    name: "Claude Code",
+    cwd: options.cwd,
+    stdio: "inherit",
+    // 必须继承 stdio 才能正确交互
+    shell: isWindows ? false : options.shell
+    // Windows上禁用shell避免进程泄漏
   });
 }
 async function startClaudeCodeEditor(_lang) {
@@ -160,18 +625,28 @@ async function startClaudeCodeEditor(_lang) {
       // 继承父进程的 stdio，这样可以在当前终端中交互
       cwd: process.cwd(),
       // 使用当前工作目录
-      shell: isWindows
-      // Windows 上使用 shell 来解析命令
+      shell: false
+      // 禁用shell模式，避免进程泄漏（Windows和Unix都适用）
     };
     try {
       const command = isWindows ? "claude.cmd" : "claude";
-      await tryStartClaude(command, ["--dangerously-skip-permissions"], spawnOptions);
+      const args = ["--dangerously-skip-permissions"];
+      if (isWindows) {
+        await tryStartClaude(command, args, spawnOptions);
+      } else {
+        await tryStartClaude(command, args, spawnOptions);
+      }
       return;
     } catch (firstError) {
       if (firstError.code === "ENOENT") {
         console.log(ansis.yellow("\u26A0\uFE0F  \u76F4\u63A5\u8C03\u7528 claude \u5931\u8D25\uFF0C\u5C1D\u8BD5\u4F7F\u7528 npx..."));
         try {
-          await tryStartClaude("npx", ["@anthropic-ai/claude-code", "--dangerously-skip-permissions"], spawnOptions);
+          const npxArgs = ["@anthropic-ai/claude-code", "--dangerously-skip-permissions"];
+          if (isWindows) {
+            await tryStartClaude("npx.cmd", npxArgs, spawnOptions);
+          } else {
+            await tryStartClaude("npx", npxArgs, spawnOptions);
+          }
           return;
         } catch (secondError) {
           throw firstError;
@@ -182,20 +657,50 @@ async function startClaudeCodeEditor(_lang) {
     }
   } catch (error) {
     console.error(ansis.red("\u274C \u542F\u52A8\u4EE3\u7801\u7F16\u8F91\u5668\u5931\u8D25:"));
-    if (error.code === "ENOENT" || error.message?.includes("command not found")) {
+    const isWindows = process.platform === "win32";
+    if (error.code === "ENOENT" || error.message?.includes("command not found") || error.message?.includes("ENOENT")) {
       console.error(ansis.yellow("\u{1F4A1} \u8BF7\u786E\u4FDD\u5DF2\u5B89\u88C5 Claude Code:"));
       console.error(ansis.gray("   npm install -g @anthropic-ai/claude-code"));
-      if (process.platform === "win32") {
+      if (isWindows) {
         console.error(ansis.yellow("\u{1F4A1} Windows \u7528\u6237\u989D\u5916\u63D0\u793A:"));
         console.error(ansis.gray("   1. \u91CD\u542F\u547D\u4EE4\u884C\u7A97\u53E3\u4EE5\u5237\u65B0 PATH \u73AF\u5883\u53D8\u91CF"));
         console.error(ansis.gray("   2. \u786E\u8BA4 npm \u5168\u5C40\u5B89\u88C5\u8DEF\u5F84\u5728 PATH \u4E2D"));
-        console.error(ansis.gray("   3. \u5C1D\u8BD5\u4F7F\u7528 npx @anthropic-ai/claude-code --dangerously-skip-permissions"));
+        console.error(ansis.gray("   3. \u5C1D\u8BD5\u4F7F\u7528 npx.cmd @anthropic-ai/claude-code --dangerously-skip-permissions"));
+        console.error(ansis.gray("   4. \u68C0\u67E5\u662F\u5426\u5B89\u88C5\u4E86 Node.js \u548C npm"));
+      }
+    } else if (error.message?.includes("spawn") || error.message?.includes("\u8FDB\u7A0B")) {
+      console.error(ansis.yellow("\u{1F4A1} \u8FDB\u7A0B\u542F\u52A8\u5931\u8D25\uFF0C\u53EF\u80FD\u662F\u8FDB\u7A0B\u7BA1\u7406\u95EE\u9898:"));
+      console.error(ansis.gray("   1. \u68C0\u67E5\u7CFB\u7EDF\u662F\u5426\u6709\u8DB3\u591F\u7684\u8D44\u6E90"));
+      console.error(ansis.gray("   2. \u5C1D\u8BD5\u5173\u95ED\u5176\u4ED6\u5E94\u7528\u7A0B\u5E8F\u91CA\u653E\u5185\u5B58"));
+      if (isWindows) {
+        console.error(ansis.gray("   3. Windows\u7528\u6237: \u5C1D\u8BD5\u4EE5\u7BA1\u7406\u5458\u6743\u9650\u8FD0\u884C"));
+        console.error(ansis.gray("   4. Windows\u7528\u6237: \u68C0\u67E5\u9632\u75C5\u6BD2\u8F6F\u4EF6\u662F\u5426\u963B\u6B62\u4E86\u8FDB\u7A0B\u542F\u52A8"));
       }
     } else {
       console.error(ansis.gray(`   \u9519\u8BEF\u4FE1\u606F: ${error.message || error}`));
+      console.error(ansis.gray(`   \u9519\u8BEF\u4EE3\u7801: ${error.code || "\u65E0"}`));
+    }
+    try {
+      const processCount = processManager.getProcessCount();
+      const runningCount = processManager.getRunningProcessCount();
+      console.error(ansis.yellow(`\u{1F4CA} \u5F53\u524D\u8FDB\u7A0B\u72B6\u6001: \u603B\u8FDB\u7A0B\u6570 ${processCount}, \u8FD0\u884C\u4E2D ${runningCount}`));
+      if (runningCount > 0) {
+        console.error(ansis.yellow("\u{1F4A1} \u68C0\u6D4B\u5230\u8FD0\u884C\u4E2D\u7684\u8FDB\u7A0B\uFF0C\u6B63\u5728\u6E05\u7406..."));
+      }
+    } catch (reportError) {
     }
     console.error(ansis.cyan("\n\u{1F4A1} \u6216\u8005\u8BF7\u590D\u5236\u4EE5\u4E0B\u547D\u4EE4\u5728\u547D\u4EE4\u884C\u4E2D\u624B\u52A8\u6267\u884C:"));
-    console.error(ansis.white("   claude --dangerously-skip-permissions"));
+    if (isWindows) {
+      console.error(ansis.white("   claude.cmd --dangerously-skip-permissions"));
+    } else {
+      console.error(ansis.white("   claude --dangerously-skip-permissions"));
+    }
+    processManager.cleanup();
+    if (isWindows) {
+      setTimeout(() => {
+        processManager.cleanup();
+      }, 100);
+    }
     throw error;
   }
 }
@@ -212,7 +717,7 @@ async function launchCodeEditor() {
 }
 async function launchCUI() {
   try {
-    const { run } = await Promise.resolve().then(function () { return runCommand; });
+    const { run } = await import('./chunks/run-command.mjs');
     console.log("\x1B[36m\u6B63\u5728\u5B89\u88C5PM2...\x1B[0m");
     await run("npm install -g pm2");
     console.log("\x1B[36m\u6B63\u5728\u5B89\u88C5AICO\u53EF\u89C6\u5316\u754C\u9762...\x1B[0m");
@@ -504,6 +1009,8 @@ async function startCodeEditor() {
     await startClaudeCodeEditor();
   } catch (error) {
     console.error(ansis.red(`\u2716 \u542F\u52A8\u4EE3\u7801\u7F16\u8F91\u5668\u5931\u8D25: ${error}`));
+    const { processManager } = await Promise.resolve().then(function () { return processManager$1; });
+    processManager.cleanup();
     process.exit(1);
   }
 }
@@ -529,14 +1036,22 @@ function customizeHelp(sections) {
       `  ${ansis.cyan("aico c")}         (--company) \u516C\u53F8\u914D\u7F6E`,
       `  ${ansis.cyan("aico p")}         (--personal) \u4E2A\u4EBA\u914D\u7F6E`,
       `  ${ansis.cyan("aico ui")}        (--ui) \u542F\u52A8\u53EF\u89C6\u5316\u754C\u9762`,
-      `  ${ansis.cyan("aico h")}         (--help) \u663E\u793A\u5E2E\u52A9`
+      `  ${ansis.cyan("aico h")}         (--help) \u663E\u793A\u5E2E\u52A9`,
+      "",
+      ansis.gray("  \u8FDB\u7A0B\u7BA1\u7406:"),
+      `  ${ansis.cyan("aico test-process")}      \u6D4B\u8BD5\u8FDB\u7A0B\u7BA1\u7406\u529F\u80FD`,
+      `  ${ansis.cyan("aico monitor-process")}   \u542F\u52A8\u8FDB\u7A0B\u76D1\u63A7`,
+      `  ${ansis.cyan("aico cleanup-process")}   \u6E05\u7406\u6240\u6709\u8FDB\u7A0B`,
+      `  ${ansis.cyan("aico test-replacement")}  \u6D4B\u8BD5\u8FDB\u7A0B\u66FF\u6362\u529F\u80FD`,
+      `  ${ansis.cyan("aico test-claude-start")} \u6D4B\u8BD5Claude Code\u542F\u52A8\u6D41\u7A0B`,
+      `  ${ansis.cyan("aico test-start-flow")}  \u6D4B\u8BD5\u5B9E\u9645\u542F\u52A8\u6D41\u7A0B\uFF08\u6A21\u62DF\uFF09`
     ].join("\n")
   });
   return sections;
 }
 async function startUI() {
   try {
-    const { run } = await Promise.resolve().then(function () { return runCommand; });
+    const { run } = await import('./chunks/run-command.mjs');
     console.log("\x1B[36m\u6B63\u5728\u5B89\u88C5\u667A\u80FD\u8F6F\u4EF6\u661F\u5DE5\u5382\u53EF\u89C6\u5316\u754C\u9762...\x1B[0m");
     await run("npm install -g pm2");
     await run("npm install -g aico-cui");
@@ -572,4 +1087,20 @@ async function main() {
   setupCommands(cli);
   cli.parse();
 }
-main().catch(console.error);
+process.on("uncaughtException", (error) => {
+  console.error("\u672A\u6355\u83B7\u7684\u5F02\u5E38:", error);
+  processManager.cleanup();
+  process.exit(1);
+});
+process.on("unhandledRejection", (reason, promise) => {
+  console.error("\u672A\u5904\u7406\u7684 Promise \u62D2\u7EDD:", reason);
+  processManager.cleanup();
+  process.exit(1);
+});
+main().catch((error) => {
+  console.error("CLI \u542F\u52A8\u5931\u8D25:", error);
+  processManager.cleanup();
+  process.exit(1);
+});
+
+export { processManager as p };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aico-cli",
-  "version": "0.4.2",
+  "version": "0.4.5",
   "packageManager": "pnpm@9.15.9",
   "description": "AI CLI",
   "repository": {

package/templates/commands/git/worktree.md

@@ -1,5 +1,5 @@
 ---
-description: 管理 Git worktree，在项目平级的 ../.zcf/项目名/ 目录下创建，支持智能默认、IDE 集成和内容迁移
+description: 管理 Git worktree，在项目平级的 ../.aico/项目名/ 目录下创建，支持智能默认、IDE 集成和内容迁移
 allowed-tools: Read(**), Exec(git worktree add, git worktree list, git worktree remove, git worktree prune, git branch, git checkout, git rev-parse, git stash, git cp, detect-ide, open-ide, which, command, basename, dirname)
 argument-hint: <add|list|remove|prune|migrate> [path] [-b <branch>] [-o|--open] [--track] [--guess-remote] [--detach] [--checkout] [--lock] [--migrate-from <source-path>] [--migrate-stash]
 # examples:
@@ -12,7 +12,7 @@ argument-hint: <add|list|remove|prune|migrate> [path] [-b <branch>] [-o|--open]
 
 # Claude Command: Git Worktree
 
-管理 Git worktree，支持智能默认、IDE 集成和内容迁移，使用结构化的 `../.zcf/项目名/` 路径。
+管理 Git worktree，支持智能默认、IDE 集成和内容迁移，使用结构化的 `../.aico/项目名/` 路径。
 
 直接执行命令并提供简洁结果。
 
@@ -38,7 +38,7 @@ argument-hint: <add|list|remove|prune|migrate> [path] [-b <branch>] [-o|--open]
 
 | 选项               | 说明                                         |
 | ------------------ | -------------------------------------------- |
-| `add [<path>]`     | 在 `../.zcf/项目名/<path>` 添加新的 worktree |
+| `add [<path>]`     | 在 `../.aico/项目名/<path>` 添加新的 worktree |
 | `migrate <target>` | 迁移内容到指定 worktree                      |
 | `list`             | 列出所有 worktree 及其状态                   |
 | `remove <path>`    | 删除指定路径的 worktree                      |
@@ -63,7 +63,7 @@ argument-hint: <add|list|remove|prune|migrate> [path] [-b <branch>] [-o|--open]
 
 2. **智能路径管理**
    - 使用 worktree 检测自动从主仓库路径计算项目名
-   - 在结构化的 `../.zcf/项目名/<path>` 目录创建 worktree
+   - 在结构化的 `../.aico/项目名/<path>` 目录创建 worktree
    - 正确处理主仓库和 worktree 执行上下文
 
 ```bash
@@ -84,13 +84,13 @@ get_main_repo_path() {
 
 MAIN_REPO_PATH=$(get_main_repo_path)
 PROJECT_NAME=$(basename "$MAIN_REPO_PATH")
-WORKTREE_BASE="$MAIN_REPO_PATH/../.zcf/$PROJECT_NAME"
+WORKTREE_BASE="$MAIN_REPO_PATH/../.aico/$PROJECT_NAME"
 
 # 始终使用绝对路径防止嵌套问题
 ABSOLUTE_WORKTREE_PATH="$WORKTREE_BASE/<path>"
 ```
 
-**关键修复**: 在现有 worktree 内创建新 worktree 时，始终使用绝对路径以防止出现类似 `../.zcf/project/.zcf/project/path` 的路径嵌套问题。
+**关键修复**: 在现有 worktree 内创建新 worktree 时，始终使用绝对路径以防止出现类似 `../.aico/project/.aico/project/path` 的路径嵌套问题。
 
 3. **Worktree 操作**
    - **add**: 使用智能分支/路径默认创建新 worktree
@@ -112,7 +112,7 @@ ABSOLUTE_WORKTREE_PATH="$WORKTREE_BASE/<path>"
 6. **安全特性**
    - **路径冲突防护**: 创建前检查目录是否已存在
    - **分支检出验证**: 确保分支未被其他地方使用
-   - **绝对路径强制**: 防止在 worktree 内创建嵌套的 `.zcf` 目录
+   - **绝对路径强制**: 防止在 worktree 内创建嵌套的 `.aico` 目录
    - **删除时自动清理**: 同时清理目录和 git 引用
    - **清晰的状态报告**: 显示 worktree 位置和分支状态
 
@@ -216,12 +216,12 @@ copy_environment_files() {
 **示例输出**:
 
 ```
-✅ Worktree created at ../.zcf/项目名/feature-ui
+✅ Worktree created at ../.aico/项目名/feature-ui
 ✅ 已复制 .env
 ✅ 已复制 .env.local
 📋 已从 .gitignore 复制 2 个环境文件
-🖥️ 是否在 IDE 中打开 ../.zcf/项目名/feature-ui？[y/n]: y
-🚀 正在用 VS Code 打开 ../.zcf/项目名/feature-ui...
+🖥️ 是否在 IDE 中打开 ../.aico/项目名/feature-ui？[y/n]: y
+🚀 正在用 VS Code 打开 ../.aico/项目名/feature-ui...
 ```
 
 ---
@@ -233,7 +233,7 @@ parent-directory/
 ├── your-project/            # 主项目
 │   ├── .git/
 │   └── src/
-└── .zcf/                    # worktree 管理
+└── .aico/                    # worktree 管理
     └── your-project/        # 项目 worktree
         ├── feature-ui/      # 功能分支
         ├── hotfix/          # 修复分支