aico-cli 0.4.2 → 0.4.4

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.4";
 
 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,434 @@ 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;
+    this.log(`\u542F\u52A8\u8FDB\u7A0B: ${processName}`, "info");
+    try {
+      const child = spawn(command, args, {
+        cwd: options.cwd || process.cwd(),
+        env: { ...process.env, ...options.env },
+        stdio: options.stdio || "pipe",
+        shell: options.shell || process.platform === "win32"
       });
-      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() {
+    for (const [pid, info] of this.processes) {
+      if (info.status === "running") {
+        try {
+          info.process.kill("SIGKILL");
+        } catch {
+        }
+      }
+    }
+    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();
+    for (const process2 of runningProcesses) {
+      try {
+        process2.process.kill(0);
+      } 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;
+  }
+  /**
+   * 添加进程到列表（用于测试）
+   */
+  addProcessForTesting(processInfo) {
+    this.processes.set(processInfo.pid, processInfo);
+  }
+  /**
+   * 替换当前进程（exec 模式）
+   * 这个方法会完全替换当前进程，不会返回
+   */
+  async replaceProcess(command, args = [], options = {}) {
+    const processName = options.name || command;
+    try {
+      this.log(`\u6E05\u7406 ${this.processes.size} \u4E2A\u7BA1\u7406\u8FDB\u7A0B...`, "info");
+      this.cleanup();
+      const { spawn: spawn2 } = await import('node:child_process');
+      const child = spawn2(command, args, {
+        stdio: "inherit",
+        // 继承所有 stdio
+        cwd: options.cwd || process.cwd(),
+        env: { ...process.env, ...options.env },
+        shell: options.shell || process.platform === "win32"
+        // 移除 detached: true，避免子进程脱离管理
+        // detached: false 是默认值，子进程会随着父进程退出而退出
+      });
+      child.on("error", (error) => {
+        this.log(`\u8FDB\u7A0B\u66FF\u6362\u5931\u8D25: ${error}`, "error");
+        process.exit(1);
       });
+      child.on("exit", (code) => {
+        this.log(`\u66FF\u6362\u8FDB\u7A0B\u5DF2\u9000\u51FA\uFF0C\u9000\u51FA\u7801: ${code}`, "info");
+        process.exit(code || 0);
+      });
+      this.registerProcess(child, processName);
+      await new Promise(() => {
+      });
+      process.exit(0);
+    } catch (error) {
+      this.log(`\u8FDB\u7A0B\u66FF\u6362\u5931\u8D25: ${error}`, "error");
+      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 +465,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 +490,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 +501,13 @@ 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);
-    });
+  await processManager.replaceProcess(command, args, {
+    name: "Claude Code",
+    cwd: options.cwd,
+    stdio: "inherit",
+    // 必须继承 stdio 才能正确交互
+    shell: options.shell
   });
 }
 async function startClaudeCodeEditor(_lang) {
@@ -182,7 +541,7 @@ 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")) {
+    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") {
@@ -196,6 +555,7 @@ async function startClaudeCodeEditor(_lang) {
     }
     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"));
+    processManager.cleanup();
     throw error;
   }
 }
@@ -212,7 +572,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 +864,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 +891,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 +942,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.4",
   "packageManager": "pnpm@9.15.9",
   "description": "AI CLI",
   "repository": {