crabatool 1.0.446 → 1.0.448

package/index.js

@@ -1,5 +1,7 @@
 var config = require('./lib/config.js');
 var start = require('./tool/start.js');
+var autoUpdate = require('./tool/autoUpdate.js');
+var processManager = require('./tool/processManager.js');
 
 exports = module.exports;
 exports.config = config;
@@ -15,25 +17,44 @@ exports.hashUtils = require('./tool/hash.js');
 
 start.initArgs();
 
-exports.run = function(options) {
+exports.run = async function(options) {
   console.log('当前环境:' + process.platform);
   console.log('助手版本:' + config.Version);
   Object.assign(config, options);
 
   start.initArgs();  // 检查注册参数
 
-  if (!checkFast(process.argv)) {
-    //process.exit(0); // 成功退出
+  // 先检查是否是命令行模式（非交互式）
+  const shouldContinueToInteractive = await checkFast(process.argv);
+
+  if (!shouldContinueToInteractive) {
+    // 命令行模式，已经执行完命令，直接返回
     return;
   }
 
+  // 只有在交互式模式下才进行分离式更新
+  if (!autoUpdate.shouldSkipUpdate()) {
+    // 执行分离式更新检查
+    const shouldContinue = await processManager.executeDetachedUpdate(
+      () => autoUpdate.checkAndUpdateDetached(false),
+      process.argv
+    );
+
+    // 如果不应该继续执行（已启动子进程），直接返回
+    if (!shouldContinue) {
+      return;
+    }
+  } else {
+    console.log('⏭️  跳过更新检查');
+  }
+
   start.showLocalVersion(true);
 
   // 2. 开发环境让开发选择功能
   start.waitInput();
 }
 
-function checkFast(args) {
+async function checkFast(args) {
   // 1. 服务端构建环境，自动化，根据命令行参数，直接调用脚手架功能
   if (args.length < 3) {
     return true;
@@ -126,6 +147,19 @@ function checkFast(args) {
     return false;
   }
 
+  // 手动更新 crabaTool 工具本身
+  if (args.includes('-updateTool')) {
+    console.log('开始更新 crabaTool...');
+    const success = await autoUpdate.checkAndUpdate(false);
+    if (success) {
+      console.log('更新完成！');
+    } else {
+      console.log(`更新失败，请检查网络连接或手动执行：npm install crabatool --registry ${config.registry}`);
+    }
+    process.exit(success ? 0 : 1);
+    return false;
+  }
+
   // 安装vscode环境
   if (args.includes('-vscode')) {
     start.installvscode();

package/lib/config.js

@@ -28,6 +28,10 @@ class Config {
 
     // 文件监听与代码检测相关配置
     this.enableFileWatcher = true; // 是否启用文件监听功能
+
+    // 分离式更新相关配置
+    this.enableDetachedUpdate = true; // 是否启用分离式更新
+    this.detachedUpdateDelay = 1500; // 子进程启动后父进程退出延迟（毫秒）
     this.TempPath = path.join(os.tmpdir(), '_crabatemp');
     this.ImageCache = path.join(this.TempPath, "_img");
     this.JsonFile = path.join(this.TempPath, "craba.json");
@@ -36,6 +40,7 @@ class Config {
     this.WebPath = path.join(this.CachePath, "www");
     this.ServerPath = path.join(this.CachePath, "server");
     this.CacheFileName = path.join(this.SaveFilePath, "craba.zip");
+    this.registry = 'http://172.17.0.236:4873';
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "crabatool",
-  "version": "1.0.446",
+  "version": "1.0.448",
   "description": "crabatool",
   "main": "index.js",
   "bin": {

package/res/client.js

@@ -56,12 +56,14 @@
       $craba._mods.def = new Date().getTime(); // 重置版本号，防止浏览器缓存
 
       var cssLinks = [];
-      var gspxLinks = [];
+      //var gspxLinks = [];
       var jsLinks = [];
       var loadedJs = $jsLoader._getLoadedScripts();
       files.forEach(function(filePath) {
-        // 没有加载过的js，不需要刷新
-        var index = loadedJs.findIndex(function(ls) {
+        if ($craba.getModName) {
+          filePath = $craba.joinPath($craba.getModName(), filePath); // 增加模块名（如果有）
+        }
+        var index = loadedJs.findIndex(function(ls) {// 没有加载过的js，不需要刷新
           return ls.includes(filePath);
         });
         if (index > -1) {
@@ -69,9 +71,10 @@
           jsLinks.push(filePath);
         } else if (filePath.includes('.css')) {
           cssLinks.push(filePath);
-        } else if (filePath.includes('.gspx')) {
-          gspxLinks.push(filePath);
         }
+        //else if (filePath.includes('.gspx')) {
+        //gspxLinks.push(filePath);
+        //}
       });
 
       // 1. 热更新css
@@ -189,9 +192,9 @@
           </div>
           <div style="padding: 10px;">
             ${allErrorFiles.map(function(file, index) {
-              var isActive = file.filePath === currentFile.filePath;
-              var fileId = 'error-file-' + index;
-              return `
+        var isActive = file.filePath === currentFile.filePath;
+        var fileId = 'error-file-' + index;
+        return `
                 <div id="${fileId}" onclick="switchErrorFile('${file.filePath}')"
                      class="${isActive ? 'active-file' : 'inactive-file'}"
                      data-filepath="${file.filePath}"
@@ -210,7 +213,7 @@
                   <div style="font-size: 11px; margin-top: 4px;">${file.errors.length} 个错误</div>
                 </div>
               `;
-            }).join('')}
+      }).join('')}
           </div>
         </div>
       `;

package/run.js

@@ -1,3 +1,7 @@
 #!/usr/bin/env node
 var crabaTool = require('./index.js'); // 引入craba脚手架工具包
-crabaTool.run();
+
+// 使用异步执行
+(async () => {
+  await crabaTool.run();
+})();

package/tool/autoUpdate.js

@@ -0,0 +1,497 @@
+const { spawn } = require('child_process');
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs');
+const ProgressBar = require('./progressbar.js');
+const config = require('../lib/config.js');
+
+class AutoUpdate {
+  constructor() {
+    this.registry = config.registry;
+    this.packageName = 'crabatool';
+    this.isUpdating = false;
+    this.progressBar = null;
+    this.progressTimer = null;
+    this.currentProgress = 0;
+  }
+
+  /**
+   * 检查并执行自动更新
+   * @param {boolean} silent - 是否静默更新（不显示详细输出）
+   * @returns {Promise<boolean>} - 更新是否成功
+   */
+  async checkAndUpdate(silent = false) {
+    if (this.isUpdating) {
+      if (!silent) {
+        console.log(chalk.yellow('⚠️  更新正在进行中，请稍候...'));
+      }
+      return false;
+    }
+
+    try {
+      this.isUpdating = true;
+
+      // 先快速检查是否需要更新
+      const needsUpdate = await this.quickCheckForUpdates(silent);
+
+      if (!needsUpdate) {
+        if (!silent) {
+          console.log(chalk.gray('📦 已是最新版本'));
+        }
+        return true;
+      }
+
+      if (!silent) {
+        console.log(chalk.blue('🔄 发现新版本，正在更新 crabaTool...'));
+      }
+
+      const updateResult = await this.performUpdate(silent);
+
+      if (updateResult.success) {
+        if (!silent) {
+          console.log(chalk.green('✅ crabaTool 更新完成'));
+          if (updateResult.updated) {
+            console.log(chalk.cyan(`📦 已更新到版本: ${updateResult.version || '最新版本'}`));
+          }
+        }
+        return true;
+      } else {
+        if (!silent) {
+          console.log(chalk.yellow('⚠️  更新失败，继续使用当前版本'));
+          if (updateResult.error) {
+            console.log(chalk.gray(`错误详情: ${updateResult.error}`));
+          }
+        }
+        return false;
+      }
+    } catch (error) {
+      if (!silent) {
+        console.log(chalk.yellow('⚠️  自动更新遇到问题，继续使用当前版本'));
+        console.log(chalk.gray(`错误: ${error.message}`));
+      }
+      return false;
+    } finally {
+      this.isUpdating = false;
+    }
+  }
+
+  /**
+   * 快速检查是否需要更新（不执行实际安装）
+   * @param {boolean} silent - 是否静默模式
+   * @returns {Promise<boolean>} - 是否需要更新
+   */
+  async quickCheckForUpdates(silent = false) {
+    return new Promise((resolve) => {
+      const command = 'npm';
+      const args = ['view', this.packageName, 'version', '--registry', this.registry];
+
+      const npmProcess = spawn(command, args, {
+        stdio: 'pipe',
+        shell: true
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      npmProcess.stdout.on('data', (data) => {
+        stdout += data.toString();
+      });
+
+      npmProcess.stderr.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      npmProcess.on('close', (code) => {
+        if (code === 0) {
+          try {
+            const latestVersion = stdout.trim();
+            const currentVersion = this.getCurrentVersion();
+
+            if (!silent) {
+              console.log(chalk.gray(`当前版本: ${currentVersion}, 最新版本: ${latestVersion}`));
+            }
+
+            // 简单的版本比较
+            resolve(latestVersion !== currentVersion);
+          } catch (e) {
+            // 如果版本比较失败，默认执行更新
+            resolve(true);
+          }
+        } else {
+          // 如果检查失败，默认执行更新
+          resolve(true);
+        }
+      });
+
+      npmProcess.on('error', () => {
+        // 如果命令执行失败，默认执行更新
+        resolve(true);
+      });
+
+      // 设置超时（10秒）
+      setTimeout(() => {
+        if (!npmProcess.killed) {
+          npmProcess.kill();
+          resolve(true); // 超时时默认执行更新
+        }
+      }, 10000);
+    });
+  }
+
+  /**
+   * 获取当前安装的版本
+   * @returns {string} - 当前版本号
+   */
+  getCurrentVersion() {
+    try {
+      const packageJsonPath = path.join(process.cwd(), 'node_modules', this.packageName, 'package.json');
+      if (fs.existsSync(packageJsonPath)) {
+        const packageInfo = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        return packageInfo.version;
+      }
+    } catch (e) {
+      // 忽略错误
+    }
+    return 'unknown';
+  }
+
+  /**
+   * 创建并初始化进度条
+   */
+  createProgressBar() {
+    if (this.progressBar) {
+      this.clearProgress();
+    }
+    this.progressBar = new ProgressBar('更新进度', 25);
+    this.currentProgress = 0;
+  }
+
+  /**
+   * 更新进度显示
+   * @param {number} percent - 进度百分比 (0-100)
+   * @param {string} statusText - 状态文本
+   */
+  updateProgress(percent, statusText = '') {
+    if (!this.progressBar) return;
+    
+    this.currentProgress = Math.max(this.currentProgress, percent);
+    this.progressBar.render({
+      value: this.currentProgress,
+      total: 100,
+      text: statusText
+    });
+  }
+
+  /**
+   * 清理进度条显示
+   * @param {string} finalText - 最终显示的文本
+   */
+  clearProgress(finalText = '') {
+    if (this.progressBar) {
+      this.progressBar.clear(finalText);
+      this.progressBar = null;
+    }
+    if (this.progressTimer) {
+      clearInterval(this.progressTimer);
+      this.progressTimer = null;
+    }
+    this.currentProgress = 0;
+  }
+
+  /**
+   * 解析npm输出，识别安装阶段
+   * @param {string} output - npm输出内容
+   * @returns {object|null} - {phase: string, progress: number, text: string}
+   */
+  parseNpmOutput(output) {
+    const npmPhases = {
+      'fetching': { progress: 35, text: '正在下载包...' },
+      'extract': { progress: 50, text: '正在解压...' },
+      'resolve': { progress: 65, text: '正在解析依赖...' },
+      'install': { progress: 78, text: '正在安装...' },
+      'link': { progress: 90, text: '正在链接...' },
+      'postinstall': { progress: 95, text: '正在完成安装...' },
+      'added': { progress: 100, text: '安装完成！' },
+      'updated': { progress: 100, text: '更新完成！' },
+      'changed': { progress: 100, text: '更改完成！' }
+    };
+
+    const lowerOutput = output.toLowerCase();
+    
+    for (const [keyword, phaseInfo] of Object.entries(npmPhases)) {
+      if (lowerOutput.includes(keyword)) {
+        return {
+          phase: keyword,
+          progress: phaseInfo.progress,
+          text: phaseInfo.text
+        };
+      }
+    }
+    
+    return null;
+  }
+
+  /**
+   * 启动基准进度定时器
+   * @param {number} maxProgress - 最大进度值
+   * @param {number} duration - 持续时间（毫秒）
+   */
+  startProgressTimer(maxProgress = 80, duration = 120000) {
+    if (this.progressTimer) {
+      clearInterval(this.progressTimer);
+    }
+    
+    const interval = 200; // 每200ms更新一次
+    const increment = (maxProgress / duration) * interval;
+    
+    this.progressTimer = setInterval(() => {
+      if (this.currentProgress < maxProgress) {
+        this.updateProgress(this.currentProgress + increment, '正在更新中...');
+      }
+    }, interval);
+  }
+
+  /**
+   * 执行实际的更新操作
+   * @param {boolean} silent - 是否静默模式
+   * @returns {Promise<{success: boolean, updated: boolean, version?: string, error?: string}>}
+   */
+  performUpdate(silent = false) {
+    return new Promise((resolve) => {
+      const command = 'npm';
+      const args = ['install', this.packageName, '--registry', this.registry];
+      
+      // 初始化进度条（非静默模式）
+      if (!silent) {
+        console.log(chalk.gray(`执行命令: ${command} ${args.join(' ')}`));
+        this.createProgressBar();
+        this.updateProgress(5, '准备更新...');
+        this.startProgressTimer(75, 120000); // 基准进度最高75%，持续2分钟
+      }
+
+      const npmProcess = spawn(command, args, {
+        stdio: silent ? 'pipe' : ['pipe', 'pipe', 'pipe'],
+        shell: true
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      // 处理进程结束的函数
+      const handleProcessEnd = (code, isTimeout = false) => {
+        // 清理定时器和进度条
+        if (!silent) {
+          if (this.progressTimer) {
+            clearInterval(this.progressTimer);
+            this.progressTimer = null;
+          }
+        }
+
+        if (code === 0) {
+          // 检查是否真的有更新
+          const wasUpdated = stdout.includes('added') || stdout.includes('updated') || stdout.includes('changed');
+          
+          // 完成进度条显示
+          if (!silent) {
+            this.updateProgress(100, wasUpdated ? '更新完成！' : '已是最新版本');
+            setTimeout(() => this.clearProgress(), 1000);
+          }
+          
+          // 尝试获取版本信息
+          let version = null;
+          try {
+            const packageJsonPath = path.join(process.cwd(), 'node_modules', this.packageName, 'package.json');
+            if (fs.existsSync(packageJsonPath)) {
+              const packageInfo = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+              version = packageInfo.version;
+            }
+          } catch (e) {
+            // 忽略版本获取错误
+          }
+
+          resolve({
+            success: true,
+            updated: wasUpdated,
+            version: version
+          });
+        } else {
+          const errorMessage = isTimeout ? '更新超时' : (stderr || `npm install 退出码: ${code}`);
+          
+          // 错误状态进度条显示
+          if (!silent) {
+            this.updateProgress(this.currentProgress, `更新失败: ${errorMessage}`);
+            setTimeout(() => this.clearProgress(), 3000);
+          }
+          
+          resolve({
+            success: false,
+            updated: false,
+            error: errorMessage
+          });
+        }
+      };
+
+      if (npmProcess.stdout) {
+        npmProcess.stdout.on('data', (data) => {
+          stdout += data.toString();
+          const output = data.toString();
+          
+          if (!silent) {
+            // 解析npm输出，更新智能进度
+            const npmPhase = this.parseNpmOutput(output);
+            if (npmPhase) {
+              this.updateProgress(npmPhase.progress, npmPhase.text);
+            }
+            
+            // 显示关键的安装信息
+            if (output.includes('added') || output.includes('updated') || output.includes('changed')) {
+              process.stdout.write(chalk.gray(output));
+            }
+          }
+        });
+      }
+
+      if (npmProcess.stderr) {
+        npmProcess.stderr.on('data', (data) => {
+          stderr += data.toString();
+          const output = data.toString();
+          
+          if (!silent) {
+            // 处理网络连接问题
+            if (output.toLowerCase().includes('network') || output.toLowerCase().includes('timeout')) {
+              this.updateProgress(this.currentProgress, '网络连接中...');
+            }
+            
+            // 只显示重要的错误信息，忽略警告
+            if (!output.includes('WARN') && !output.includes('deprecated')) {
+              process.stderr.write(chalk.yellow(output));
+            }
+          }
+        });
+      }
+
+      npmProcess.on('close', (code) => {
+        handleProcessEnd(code);
+      });
+
+      npmProcess.on('error', (error) => {
+        if (!silent) {
+          this.updateProgress(this.currentProgress, `进程错误: ${error.message}`);
+          setTimeout(() => this.clearProgress(), 3000);
+        }
+        
+        resolve({
+          success: false,
+          updated: false,
+          error: error.message
+        });
+      });
+
+      // 设置超时（2分钟）
+      setTimeout(() => {
+        if (!npmProcess.killed) {
+          npmProcess.kill();
+          handleProcessEnd(-1, true);
+        }
+      }, 2 * 60 * 1000);
+    });
+  }
+
+  /**
+   * 检查是否应该跳过自动更新
+   * @returns {boolean}
+   */
+  shouldSkipUpdate() {
+    // 检查环境变量
+    if (process.env.CRABATOOL_SKIP_UPDATE === 'true') {
+      return true;
+    }
+
+    // 检查命令行参数
+    if (process.argv.includes('--skip-update')) {
+      return true;
+    }
+
+    // 在CI环境中跳过更新
+    if (process.env.CI === 'true' || process.env.CONTINUOUS_INTEGRATION === 'true') {
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * 分离式更新检查和执行
+   * 专门用于分离式子进程更新流程
+   * @param {boolean} silent - 是否静默模式
+   * @returns {Promise<{updated: boolean, success: boolean, version?: string}>}
+   */
+  async checkAndUpdateDetached(silent = false) {
+    if (this.isUpdating) {
+      if (!silent) {
+        console.log(chalk.yellow('⚠️  更新正在进行中，请稍候...'));
+      }
+      return { updated: false, success: false };
+    }
+
+    try {
+      this.isUpdating = true;
+
+      // 先快速检查是否需要更新
+      const needsUpdate = await this.quickCheckForUpdates(silent);
+
+      if (!needsUpdate) {
+        if (!silent) {
+          console.log(chalk.gray('📦 已是最新版本'));
+        }
+        return { updated: false, success: true };
+      }
+
+      if (!silent) {
+        console.log(chalk.blue('🔄 发现新版本，正在更新 crabaTool...'));
+      }
+
+      const updateResult = await this.performUpdate(silent);
+
+      if (updateResult.success && updateResult.updated) {
+        if (!silent) {
+          console.log(chalk.green('✅ crabaTool 更新完成'));
+          console.log(chalk.cyan(`📦 已更新到版本: ${updateResult.version || '最新版本'}`));
+        }
+        return {
+          updated: true,
+          success: true,
+          version: updateResult.version
+        };
+      } else {
+        if (!silent) {
+          console.log(chalk.yellow('⚠️  更新失败或无实际更新'));
+          if (updateResult.error) {
+            console.log(chalk.gray(`错误详情: ${updateResult.error}`));
+          }
+        }
+        return {
+          updated: false,
+          success: updateResult.success,
+          error: updateResult.error
+        };
+      }
+    } catch (error) {
+      if (!silent) {
+        console.log(chalk.yellow('⚠️  自动更新遇到问题'));
+        console.log(chalk.gray(`错误: ${error.message}`));
+      }
+      return {
+        updated: false,
+        success: false,
+        error: error.message
+      };
+    } finally {
+      this.isUpdating = false;
+    }
+  }
+
+
+}
+
+module.exports = new AutoUpdate();

package/tool/processManager.js

@@ -0,0 +1,254 @@
+/*
+  分离式子进程管理器
+  功能: 实现更新后的分离式子进程启动，避免更新过程中的进程冲突
+*/
+
+const { spawn } = require('child_process');
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs');
+const config = require('../lib/config.js');
+
+/**
+ * 分离式进程管理器
+ * 用于处理更新后的子进程启动和父进程优雅退出
+ */
+class ProcessManager {
+  constructor() {
+    this.isChildProcess = false;
+    this.originalArgs = [];
+    this.childProcess = null;
+    
+    // 检查是否是子进程
+    this.checkIfChildProcess();
+  }
+
+  /**
+   * 检查当前进程是否是子进程
+   */
+  checkIfChildProcess() {
+    // 通过环境变量检查
+    this.isChildProcess = process.env.CRABATOOL_CHILD_PROCESS === 'true';
+    
+    // 通过命令行参数检查
+    if (process.argv.includes('--child-process')) {
+      this.isChildProcess = true;
+    }
+    
+    if (this.isChildProcess) {
+      console.log(chalk.blue('🔄 子进程已启动，运行更新后的代码'));
+    }
+  }
+
+  /**
+   * 启动分离式子进程
+   * @param {Array} originalArgs - 原始命令行参数
+   * @param {Object} options - 启动选项
+   * @returns {Promise<boolean>} - 是否成功启动子进程
+   */
+  async startDetachedChild(originalArgs = [], options = {}) {
+    try {
+      // 准备子进程参数
+      const childArgs = this.prepareChildArgs(originalArgs);
+
+      // 获取当前执行的脚本路径
+      const scriptPath = this.getScriptPath();
+
+      console.log(chalk.blue('🚀 启动分离式子进程...'));
+      console.log(chalk.gray(`执行命令: node ${scriptPath} ${childArgs.join(' ')}`));
+
+      // 启动子进程，不分离，让子进程接管终端
+      const child = spawn('node', [scriptPath, ...childArgs], {
+        detached: false, // 不分离
+        stdio: 'inherit', // 继承输入输出
+        env: {
+          ...process.env,
+          CRABATOOL_CHILD_PROCESS: 'true'
+        }
+      });
+
+      // 等待子进程结束，然后父进程也结束
+      child.on('close', (code) => {
+        process.exit(code || 0);
+      });
+
+      child.on('error', (error) => {
+        console.error(chalk.red(`子进程启动失败: ${error.message}`));
+        process.exit(1);
+      });
+
+      // 等待一小段时间确保子进程启动
+      await this.delay(500);
+
+      return true;
+    } catch (error) {
+      console.log(chalk.red(`❌ 子进程启动失败: ${error.message}`));
+      return false;
+    }
+  }
+
+  /**
+   * 准备子进程参数
+   * @param {Array} originalArgs - 原始参数
+   * @returns {Array} - 处理后的参数
+   */
+  prepareChildArgs(originalArgs) {
+    // 过滤掉 node 和脚本路径
+    const filteredArgs = originalArgs.slice(2);
+    
+    // 添加子进程标识
+    if (!filteredArgs.includes('--child-process')) {
+      filteredArgs.push('--child-process');
+    }
+    
+    return filteredArgs;
+  }
+
+  /**
+   * 获取当前脚本路径
+   * @returns {string} - 脚本路径
+   */
+  getScriptPath() {
+    // 尝试多种方式获取脚本路径
+    let scriptPath = process.argv[1];
+    
+    // 如果是通过 npm 或其他方式启动，尝试找到实际的入口文件
+    if (!scriptPath || !fs.existsSync(scriptPath)) {
+      // 查找项目根目录的 index.js
+      const projectRoot = process.cwd();
+      const possiblePaths = [
+        path.join(projectRoot, 'index.js'),
+        path.join(projectRoot, 'app.js'),
+        path.join(projectRoot, 'main.js')
+      ];
+      
+      for (const possiblePath of possiblePaths) {
+        if (fs.existsSync(possiblePath)) {
+          scriptPath = possiblePath;
+          break;
+        }
+      }
+    }
+    
+    return scriptPath;
+  }
+
+  /**
+   * 优雅退出父进程
+   * @param {number} exitCode - 退出码
+   * @param {number} delay - 延迟时间（毫秒）
+   */
+  async gracefulExit(exitCode = 0, delay = null) {
+    console.log(chalk.yellow('🔄 父进程准备退出...'));
+
+    // 使用配置的延迟时间或传入的延迟时间
+    const actualDelay = delay !== null ? delay : config.detachedUpdateDelay || 2000;
+
+    // 等待一段时间确保子进程稳定运行
+    await this.delay(actualDelay);
+
+    console.log(chalk.green('👋 父进程优雅退出'));
+    process.exit(exitCode);
+  }
+
+  /**
+   * 延迟函数
+   * @param {number} ms - 延迟毫秒数
+   * @returns {Promise}
+   */
+  delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  /**
+   * 检查是否应该启动分离式更新流程
+   * @returns {boolean}
+   */
+  shouldUseDetachedUpdate() {
+    // 如果已经是子进程，不再启动分离式更新
+    if (this.isChildProcess) {
+      return false;
+    }
+
+    // 检查配置文件
+    if (!config.enableDetachedUpdate) {
+      return false;
+    }
+
+    // 检查环境变量
+    if (process.env.CRABATOOL_DISABLE_DETACHED === 'true') {
+      return false;
+    }
+
+    // 检查命令行参数
+    if (process.argv.includes('--no-detached')) {
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * 执行分离式更新流程
+   * @param {Function} updateFunction - 更新函数
+   * @param {Array} originalArgs - 原始参数
+   * @returns {Promise<boolean>} - 是否需要继续执行
+   */
+  async executeDetachedUpdate(updateFunction, originalArgs = process.argv) {
+    // 如果是子进程，直接返回继续执行
+    if (this.isChildProcess) {
+      console.log(chalk.blue('📦 子进程运行中，跳过更新检查'));
+      return true;
+    }
+    
+    // 如果不应该使用分离式更新，返回继续执行
+    if (!this.shouldUseDetachedUpdate()) {
+      return true;
+    }
+    
+    try {
+      console.log(chalk.blue('🔍 检查更新（分离式模式）...'));
+      
+      // 执行更新检查
+      const updateResult = await updateFunction();
+      
+      if (updateResult && updateResult.updated) {
+        console.log(chalk.green('✅ 更新完成，启动新进程...'));
+        
+        // 启动分离式子进程
+        const childStarted = await this.startDetachedChild(originalArgs);
+        
+        if (childStarted) {
+          // 子进程已启动，父进程不需要继续执行
+          // 子进程会接管所有后续操作
+          return false;
+        } else {
+          console.log(chalk.yellow('⚠️  子进程启动失败，继续使用当前进程'));
+          return true; // 继续执行
+        }
+      } else {
+        console.log(chalk.gray('📦 无需更新或更新失败，继续执行'));
+        return true; // 继续执行
+      }
+    } catch (error) {
+      console.log(chalk.red(`❌ 分离式更新流程失败: ${error.message}`));
+      return true; // 继续执行
+    }
+  }
+
+  /**
+   * 获取进程状态信息
+   * @returns {Object} - 进程状态
+   */
+  getStatus() {
+    return {
+      isChildProcess: this.isChildProcess,
+      pid: process.pid,
+      ppid: process.ppid,
+      shouldUseDetached: this.shouldUseDetachedUpdate(),
+      args: process.argv
+    };
+  }
+}
+
+module.exports = new ProcessManager();

package/tool/start.js

@@ -10,67 +10,101 @@ class Start {
 
   }
 
-  waitInput() {
+  async waitInput() {
     const rl = readline.createInterface({
       input: process.stdin,
       output: process.stdout
     });
 
-    const question = rlPromisify(rl.question.bind(rl));
-
-    (async function() {
-      var ques = [
-        "---------------------------------------------------------------------------------------------------------",
-        "1. 启动服务。\t\t\t\t主要包含：自动合并打包init.js和biz.js，查看本地平台的版本",
-        "2. 更新当前项目的平台，然后启动服务。\t主要包含：从<内网>拉取环境相关资源，再拷贝到webPath路径下覆盖老文件，替代手工操作，同时解决npm不稳定问题",
-        "3. 查询最新平台版本和日期。\t\t主要包含：从<内网>拉取最新平台版本，开发好及时更新补丁",
-        "4. 校验当前项目js和gspx语法。\t\t主要包含：对本地js语法做一次初步预检避免上线后才发现问题；比如：编码、let、const、=>、async、await、then、缺function",
-        "5. 打包当前项目前端所有js。\t\t主要包含：前端es6语法的打包和js的统一压缩处理",
-        "6. 安装或更新IDEA环境。\t\t\t主要包含：从<内网>拉取环境相关资源，包括智能语法、新增页面模板、更多新功能",
-        "7. 安装或更新vscode环境。\t\t主要包含：从<内网>拉取环境相关资源，包括智能语法、新增页面模板、ctrl+alt+n、alt+j快捷键",
-        "8. 新建Craba项目。\t\t\t主要包含：从<内网>拉取环境相关资源，根据模板创建新项目，避免手工拷贝文件",
-        "9. 结束 \t\t\t\t按Ctrl+C即可退出",
-        "#. 如果你对[nodejs版本的平台助手]有更多建议或想法可反馈给技术架构组改进哦，使用文档和介绍: http://crabadoc.ca.com/index.html?#~/Pages/Guide.gspx?id=1655080677276",
-        "---------------------------------------------------------------------------------------------------------",
-        "请输入对应功能的编号（数字）："
-      ];
-      const num = await question(ques.join('\r\n'));
-      if (num != 8) {
-        rl.close(); // 关闭输入等待
-      }
-
-      if (num == 1) {
-        start.runServer();
-      } else if (num == 2) {
-        start.update();
-      } else if (num == 3) {
-        start.showNewVersion();
-        start.waitInput(); // 重复
-      } else if (num == 4) {
-        start.checkAllJs();
-      } else if (num == 5) {
-        start.compressAllJs();
-      } else if (num == 6) {
-        start.installIDEA();
-      } else if (num == 7) {
-        start.installvscode();
-      } else if (num == 8) {
-        var options = {};
-        options.type = await question('选择项目类型：1. 普通craba纯前端项目;  2. ngp微前端项目；输入编号：');
-        if (options.type != 1 && options.type != 2) options.type = 1;
-        if (options.type == 2) {
-          options.modName = await question('请输入微服务的模块名称：');
-          if (!options.modName) options.modName = 'emptyname';
+    const question = (prompt) => {
+      return new Promise((resolve) => {
+        rl.question(prompt, resolve);
+      });
+    };
+
+    try {
+      while (true) {
+        // 分离菜单内容和提示信息
+        var menuLines = [
+          "---------------------------------------------------------------------------------------------------------",
+          "1. 启动服务。\t\t\t\t主要包含：自动合并打包init.js和biz.js，查看本地平台的版本",
+          "2. 更新当前项目的平台，然后启动服务。\t主要包含：从<内网>拉取环境相关资源，再拷贝到webPath路径下覆盖老文件，替代手工操作，同时解决npm不稳定问题",
+          "3. 查询最新平台版本和日期。\t\t主要包含：从<内网>拉取最新平台版本，开发好及时更新补丁",
+          "4. 校验当前项目js和gspx语法。\t\t主要包含：对本地js语法做一次初步预检避免上线后才发现问题；比如：编码、let、const、=>、async、await、then、缺function",
+          "5. 打包当前项目前端所有js。\t\t主要包含：前端es6语法的打包和js的统一压缩处理",
+          "6. 安装或更新IDEA环境。\t\t\t主要包含：从<内网>拉取环境相关资源，包括智能语法、新增页面模板、更多新功能",
+          "7. 安装或更新vscode环境。\t\t主要包含：从<内网>拉取环境相关资源，包括智能语法、新增页面模板、ctrl+alt+n、alt+j快捷键",
+          "8. 新建Craba项目。\t\t\t主要包含：从<内网>拉取环境相关资源，根据模板创建新项目，避免手工拷贝文件",
+          "9. 更新 crabaTool 工具。\t\t\t主要包含：从内网更新 crabaTool 工具到最新版本",
+          "0. 结束 \t\t\t\t按Ctrl+C即可退出",
+          "#. 如果你对[nodejs版本的平台助手]有更多建议或想法可反馈给技术架构组改进哦，使用文档和介绍: http://crabadoc.ca.com/index.html?#~/Pages/Guide.gspx?id=1655080677276",
+          "---------------------------------------------------------------------------------------------------------"
+        ];
+
+        // 先显示菜单
+        console.log(menuLines.join('\r\n'));
+
+        // 然后单独显示提示并等待输入
+        const num = await question('请输入对应功能的编号（数字）：');
+
+        if (num == 1) {
+          rl.close();
+          start.runServer();
+          break;
+        } else if (num == 2) {
+          rl.close();
+          start.update();
+          break;
+        } else if (num == 3) {
+          start.showNewVersion();
+          // 继续循环，重新显示菜单
+          console.log('\r\n');
+        } else if (num == 4) {
+          rl.close();
+          start.checkAllJs();
+          break;
+        } else if (num == 5) {
+          rl.close();
+          start.compressAllJs();
+          break;
+        } else if (num == 6) {
+          rl.close();
+          start.installIDEA();
+          break;
+        } else if (num == 7) {
+          rl.close();
+          start.installvscode();
+          break;
+        } else if (num == 8) {
+          var options = {};
+          options.type = await question('选择项目类型：1. 普通craba纯前端项目;  2. ngp微前端项目；输入编号：');
+          if (options.type != 1 && options.type != 2) options.type = 1;
+          if (options.type == 2) {
+            options.modName = await question('请输入微服务的模块名称：');
+            if (!options.modName) options.modName = 'emptyname';
+          }
+          options.projectPath = await waitFolder(question);
+
+          rl.close();
+          start.createProject(options);
+          break;
+        } else if (num == 9) {
+          rl.close();
+          start.updateTool();
+          break;
+        } else if (num == 0) {
+          rl.close();
+          console.log('👋 程序已退出');
+          process.exit(0);
+        } else {
+          console.error('无效输入,请重新选择。\r\n');
+          // 继续循环，重新显示菜单
         }
-        options.projectPath = await waitFolder(question);
-
-        rl.close(); // 关闭输入等待
-        start.createProject(options);
-      } else if (num != 9) {
-        console.error('无效输入,请继续。\r\n\r\n');
-        start.waitInput(); // 重复
       }
-    })();
+    } catch (error) {
+      console.error('菜单处理出错:', error);
+      rl.close();
+    }
   }
 
   initArgs() {
@@ -232,6 +266,28 @@ class Start {
     utils.log('');
   }
 
+  // 更新 crabaTool 工具本身
+  async updateTool() {
+    const autoUpdate = require('./autoUpdate.js');
+    console.log('开始更新 crabaTool 工具...');
+    try {
+      const success = await autoUpdate.checkAndUpdate(false);
+      if (success) {
+        console.log('✅ crabaTool 更新完成！');
+        console.log('💡 提示：重新启动 crabaTool 以使用最新版本');
+      } else {
+        console.log('⚠️  更新失败，请检查网络连接或手动执行：');
+        console.log(`npm install crabatool --registry ${config.registry}`);
+      }
+    } catch (error) {
+      console.log('❌ 更新过程中出现错误：', error.message);
+      console.log(`💡 请手动执行：npm install crabatool --registry ${config.registry}`);
+    }
+
+    // 更新完成后返回主菜单
+    console.log('\n按任意ctrl+c键返回...');
+  }
+
 
   // 安装或更新IDEA环境，主要包含：智能语法、新增页面模板
   installIDEA() {
@@ -353,8 +409,3 @@ async function waitFolder(question) {
   return projectPath;
 }
 
-function rlPromisify(fn) {
-  return async function(t) {
-    return new Promise(function(resolve) { fn(t, resolve) });
-  };
-}