daodou-command 1.4.7 → 1.4.8

package/lib/commands/build.js

@@ -1,6 +1,5 @@
 const chalk = require('chalk');
 const ora = require('ora');
-const inquirer = require('inquirer');
 const path = require('path');
 const fs = require('fs');
 const { getCurrentBranch } = require('../utils/git');
@@ -18,20 +17,19 @@ class BuildConfigManager {
 
   checkAndCreateConfig() {
     try {
-      // 检查是否有配置文件
       if (!fs.existsSync(this.configManager.projectConfigFile) && !fs.existsSync(this.configManager.configFile)) {
         this.configManager.createDefaultConfig();
-        console.log('📝 已为你创建配置文件');
-        console.log('💡 请编辑该文件，将 your-xxx 替换为你的实际配置信息');
-        console.log('📍 文件位置：' + this.configManager.projectConfigFile);
-        console.log('🔄 填写完成后请重新运行命令');
+        console.log('');
+        console.log(chalk.yellow('  ⚠ 已创建默认配置文件'));
+        console.log(chalk.dim('    请编辑后重新运行:'));
+        console.log('    ' + this.configManager.projectConfigFile);
         process.exit(0);
       }
-      
+
       this.loadConfig();
       this.checkTemplateValues();
     } catch (e) {
-      console.error('❌ 读取配置文件失败，请检查文件格式或内容是否正确。');
+      console.error(chalk.red('  ✖ 读取配置文件失败，请检查文件格式'));
       process.exit(1);
     }
   }
@@ -50,14 +48,14 @@ class BuildConfigManager {
     ];
     const hasTemplateValues = Object.values(this.localConfig).some(value => templateValues.includes(value));
     if (hasTemplateValues) {
-      console.log(chalk.yellow('⚠️ 检测到配置文件包含模板值，请修改以下变量：'));
+      console.log('');
+      console.log(chalk.yellow('  ⚠ 配置文件包含模板值，请修改:'));
       Object.entries(this.localConfig).forEach(([key, value]) => {
         if (templateValues.includes(value)) {
-          console.log(chalk.cyan(`   ${key}=${value}`));
+          console.log(chalk.dim(`    ${key}`) + ' = ' + chalk.cyan(value));
         }
       });
-      console.log(chalk.green('📍 文件位置：' + this.configManager.projectConfigFile));
-      console.log(chalk.cyan('🔄 修改完成后请重新运行命令'));
+      console.log(chalk.dim('    文件: ') + this.configManager.projectConfigFile);
       process.exit(0);
     }
   }
@@ -65,34 +63,30 @@ class BuildConfigManager {
   validateConfig() {
     const requiredKeys = ['jenkinsBase', 'jenkinsToken', 'jenkinsUrl', 'jobName'];
     const missingKeys = [];
-    
+
     for (const key of requiredKeys) {
       if (!this.localConfig[key]) {
         missingKeys.push(key);
       }
     }
-    
+
     if (missingKeys.length > 0) {
-      console.error('❌ 配置信息缺失，请检查以下配置：');
+      console.log('');
+      console.log(chalk.red('  ✖ 缺少必要配置:'));
       missingKeys.forEach(key => {
-        console.error(`   - ${key}`);
+        console.log(chalk.dim(`    - ${key}`));
       });
-      console.error('\n💡 提示：');
-      console.error('   1. 请在项目配置文件 (.daodourc) 中取消注释并填写上述配置');
+      console.log('');
+      console.log(chalk.dim('  请在 .daodourc 或 ~/.daodou/config.json 中补充'));
       if (missingKeys.includes('jobName')) {
-        console.error('   2. jobName 参数必须从本地配置文件设置，不能使用全局配置');
-      } else {
-        console.error('   2. 或者确保全局配置文件 (~/.daodou/config.json) 中包含这些配置');
+        console.log(chalk.dim('  jobName 必须在项目配置 (.daodourc) 中设置'));
       }
-      console.error('   3. 项目配置优先于全局配置');
       process.exit(1);
     }
-    
-    // 验证构建参数配置
+
     if (this.localConfig.buildParams) {
-      const buildParams = this.localConfig.buildParams;
-      if (typeof buildParams !== 'object') {
-        console.error('❌ buildParams 必须是对象格式');
+      if (typeof this.localConfig.buildParams !== 'object') {
+        console.log(chalk.red('  ✖ buildParams 必须是对象格式'));
         process.exit(1);
       }
     }
@@ -151,48 +145,37 @@ class BuildCommand {
     this.jenkinsConfig.baseUrl = config.jenkinsUrl;
     this.jenkinsBase = config.jenkinsBase;
     this.jenkinsToken = config.jenkinsToken;
-    console.log(chalk.blue('🔧 刀豆构建工具启动中...\n'));
 
-    // 1. 获取分支名称（强制从Git获取，不依赖配置）
+    console.log('');
+    console.log(chalk.bold('  🔧 刀豆构建工具'));
+    console.log(chalk.dim('  ─────────────────────────'));
+
+    // 1. 获取分支名称
     const branch = await this.getBranch(options);
-    console.log(chalk.green(`✅ 当前分支: ${chalk.cyan(branch)}\n`));
 
-    // 2. 浏览器登录Jenkins
+    // 2. 登录 & 认证
     await this.browserAuth.ensureLogin();
-
-    // 3. 设置Jenkins认证
     this.setupJenkinsAuth();
-
-    // 4. 检查 Jenkins 会话有效性
     await this.ensureJenkinsSession();
 
-    // 5. 构建任务名称和URL
+    // 3. 构建参数
     const jobName = this.buildJobName(config);
     const jenkinsUrl = this.buildJobUrl(config, jobName);
     const params = this.buildParams(config, branch);
 
-    // 7. 确认参数
-    console.log(chalk.yellow('📋 构建参数:'));
-    console.log(`  jobName: ${jobName}`);
+    console.log('');
+    console.log(chalk.dim('  ─────────────────────────'));
+    console.log('  ' + chalk.dim('任务') + '  ' + chalk.cyan(jobName));
+    console.log('  ' + chalk.dim('分支') + '  ' + chalk.cyan(branch));
     Object.entries(params).forEach(([key, value]) => {
-      if (key === 'token') return; // 不显示 token
-      console.log(`  ${chalk.cyan(key)}: ${chalk.magenta(value)}`);
+      if (key === 'token' || key === 'GIT_BRANCH') return;
+      console.log('  ' + chalk.dim(key) + '  ' + value);
     });
+    console.log(chalk.dim('  ─────────────────────────'));
+    console.log('');
 
-    await inquirer.prompt([
-      {
-        type: 'input',
-        name: 'confirm',
-        message: chalk.yellow('按回车确认开始构建，Ctrl+C 取消...'),
-        default: undefined,
-        transformer: () => ''
-      }
-    ]);
-    // 只要不是 Ctrl+C 终止就继续
-
-    // 8. 记录本地计时起点
+    // 4. 触发构建
     const buildStartTime = Date.now();
-    // 9. 触发Jenkins构建并监听进度
     await this.triggerAndMonitorBuild(jobName, params, buildStartTime);
   }
 
@@ -233,33 +216,19 @@ class BuildCommand {
    * @returns {Promise<string>} 分支名称
    */
   async getBranch(options) {
-    // 如果命令行指定了分支，优先使用命令行参数
     if (options.branch) {
-      console.log(chalk.yellow(`⚠️ 使用命令行指定的分支: ${options.branch}`));
+      console.log(chalk.yellow('  ⚠ 使用指定分支 ') + chalk.cyan(options.branch));
       return options.branch;
     }
 
-    // 否则强制从Git获取当前分支
-    const spinner = ora('检测当前Git分支...').start();
-    try {
-      const branch = await getCurrentBranch();
-      spinner.succeed('分支检测完成');
-      return branch;
-    } catch (error) {
-      spinner.fail('分支检测失败');
-      throw new Error(`无法检测当前Git分支: ${error.message}\n💡 请确保当前目录是Git仓库，或使用 --branch 参数指定分支`);
-    }
-  }
-
-  async detectBranch() {
-    const spinner = ora('检测当前分支...').start();
+    const spinner = ora({ text: '检测 Git 分支...', indent: 2 }).start();
     try {
       const branch = await getCurrentBranch();
-      spinner.succeed('分支检测完成');
+      spinner.succeed('分支 ' + chalk.cyan(branch));
       return branch;
     } catch (error) {
       spinner.fail('分支检测失败');
-      throw new Error(`无法检测当前分支: ${error.message}`);
+      throw new Error(`无法检测 Git 分支: ${error.message}\n  请确保当前目录是 Git 仓库，或使用 --branch 指定`);
     }
   }
 
@@ -276,18 +245,24 @@ class BuildCommand {
   }
 
   async ensureJenkinsSession() {
+    const spinner = ora({ text: '验证 Jenkins 会话...', indent: 2 }).start();
     try {
-      // 使用拦截器自动带上 Cookie
       const resp = await this.axios.get(this.jenkinsConfig.baseUrl);
-      
-      // 302 跳转到登录页、401/403 都视为未登录
       if (resp.status === 401 || resp.status === 403) throw new Error('未登录');
       if (resp.status === 302 && resp.headers.location && resp.headers.location.includes('casdoor')) throw new Error('未登录');
-      // 其它情况视为已登录
+      spinner.succeed('认证有效');
       return true;
     } catch (e) {
-      // 自动重新登录
-      console.log(chalk.yellow('⚠️ Cookie 已失效，自动重新登录...'));
+      // 优先用 Casdoor cookie 静默刷新
+      spinner.text = 'Session 已过期，正在刷新...';
+      const refreshed = await this.browserAuth.refreshSessionViaCasdoor();
+      if (refreshed) {
+        this.setupJenkinsAuth();
+        spinner.succeed('Session 已刷新');
+        return true;
+      }
+      // Casdoor 也过期，启动浏览器重新登录
+      spinner.warn('Session 已过期，需要重新登录');
       await this.browserAuth.login();
       this.setupJenkinsAuth();
       return true;
@@ -295,16 +270,14 @@ class BuildCommand {
   }
 
   async triggerAndMonitorBuild(jobName, params, buildStartTime) {
-    // 1. 触发构建
-    const spinner = ora('正在触发Jenkins构建...').start();
+    const spinner = ora({ text: '触发构建...', indent: 2 }).start();
     try {
       const queueId = await this.triggerBuild(jobName, params);
-      spinner.succeed(chalk.green(`✅ Jenkins构建已触发，队列号: ${queueId}`));
-      // 2. 监听队列，获取build number
+      spinner.succeed('构建已触发 ' + chalk.dim(`队列 #${queueId}`));
       await this.monitorQueueAndBuild(jobName, queueId, buildStartTime);
     } catch (error) {
-      spinner.fail('❌ Jenkins构建触发失败');
-      console.error(chalk.red('构建失败:'), error.message);
+      spinner.fail('构建触发失败');
+      console.error(chalk.red('  ' + error.message));
     }
   }
 
@@ -333,24 +306,22 @@ class BuildCommand {
         const location = response.headers.location;
         const queueId = location ? location.replace(/\/$/, '').split('/').pop() : null;
         if (!queueId) {
-          console.log(chalk.yellow('⚠️ 未能正确获取队列号，可能是Jenkins配置问题。'));
+          console.log(chalk.yellow('  ⚠ 未能获取队列号'));
         }
         return queueId;
       } else {
         throw new Error('触发构建失败');
       }
     } catch (error) {
-      console.log(chalk.red('❌ Jenkins构建触发失败: ' + error.message));
-      console.log(chalk.yellow('💡 请检查Jenkins权限、Token、参数设置，或联系管理员。'));
       throw new Error(`触发构建失败: ${error.message}`);
     }
   }
 
   async monitorQueueAndBuild(jobName, queueId, buildStartTime) {
-    const spinner = ora('等待Jenkins分配构建号...').start();
+    const spinner = ora({ text: '等待分配构建号...', indent: 2 }).start();
     let buildNumber = null;
     let count = 0;
-    while (!buildNumber && count < 60) { // 最多等2分钟
+    while (!buildNumber && count < 60) {
       try {
         const response = await this.axios.get(`${this.jenkinsConfig.baseUrl}queue/item/${queueId}/api/json`, {
           timeout: 10000
@@ -358,85 +329,89 @@ class BuildCommand {
         const item = response.data;
         if (item.executable && item.executable.number) {
           buildNumber = item.executable.number;
-          spinner.succeed(chalk.green(`✅ 已分配构建号: ${buildNumber}`));
+          spinner.succeed('构建号 ' + chalk.cyan(`#${buildNumber}`));
           break;
         }
-        spinner.text = '等待Jenkins分配构建号...';
       } catch (e) {
-        spinner.text = '队列查询中...';
+        // 队列查询失败不影响主流程
       }
       await new Promise(r => setTimeout(r, 2000));
       count++;
     }
     if (!buildNumber) {
-      spinner.fail('❌ 超时未分配构建号');
+      spinner.fail('超时未分配构建号');
       return;
     }
-    // 监听构建进度
     await this.monitorBuild(jobName, buildNumber, buildStartTime);
   }
 
   async monitorBuild(jobName, buildNumber, buildStartTime) {
+    const formatTime = (ms) => {
+      const s = Math.floor(ms / 1000);
+      return s >= 60 ? `${Math.floor(s / 60)}m${s % 60}s` : `${s}s`;
+    };
+
     const spinner = ora({
-      text: 'Jenkins构建中... [BUILDING] 0s',
+      text: '构建中 ' + chalk.dim('0s'),
+      indent: 2,
       spinner: 'dots'
     }).start();
+
+    // 独立定时器刷新计时，不受 API 请求阻塞
+    const timer = setInterval(() => {
+      spinner.text = '构建中 ' + chalk.dim(formatTime(Date.now() - buildStartTime));
+    }, 200);
+
     let building = true;
     let lastLog = '';
     let lastLogTime = 0;
-    while (building) {
-      try {
-        const response = await this.axios.get(`${this.jenkinsConfig.baseUrl}job/${encodeURIComponent(jobName)}/${buildNumber}/api/json`, {
-          timeout: 10000
-        });
-        const buildInfo = response.data;
-        building = buildInfo.building;
-        // 计时
-        const duration = building
-          ? Math.floor((Date.now() - buildStartTime) / 1000)
-          : Math.floor((Date.now() - buildStartTime) / 1000);
-        spinner.text = `Jenkins构建中... [${buildInfo.result || 'BUILDING'}] ${duration}s`;
-        // 实时输出日志片段（每3秒刷新一次）
-        const now = Date.now();
-        if (now - lastLogTime > 2900) {
-          try {
-            const logResponse = await this.axios.get(`${this.jenkinsConfig.baseUrl}job/${encodeURIComponent(jobName)}/${buildNumber}/consoleText`, {
-              timeout: 10000
-            });
-            const log = logResponse.data;
-            const lines = log.split('\n');
-            const lastLines = lines.slice(-5).join('\n');
-            if (lastLines !== lastLog) {
-              spinner.stop();
-              process.stdout.write(chalk.gray(lastLines) + '\n');
-              spinner.start();
-              spinner.text = `Jenkins构建中... [${buildInfo.result || 'BUILDING'}] ${duration}s`;
-              lastLog = lastLines;
+    try {
+      while (building) {
+        try {
+          const response = await this.axios.get(`${this.jenkinsConfig.baseUrl}job/${encodeURIComponent(jobName)}/${buildNumber}/api/json`, {
+            timeout: 10000
+          });
+          const buildInfo = response.data;
+          building = buildInfo.building;
+
+          // 实时输出日志片段
+          const now = Date.now();
+          if (now - lastLogTime > 2900) {
+            try {
+              const logResponse = await this.axios.get(`${this.jenkinsConfig.baseUrl}job/${encodeURIComponent(jobName)}/${buildNumber}/consoleText`, {
+                timeout: 10000
+              });
+              const log = logResponse.data;
+              const lines = log.split('\n');
+              const lastLines = lines.slice(-5).join('\n');
+              if (lastLines !== lastLog) {
+                spinner.stop();
+                process.stdout.write(chalk.dim(lastLines) + '\n');
+                spinner.start();
+                lastLog = lastLines;
+              }
+              lastLogTime = now;
+            } catch (logError) {
+              // 日志获取失败不影响主流程
             }
-            lastLogTime = now;
-          } catch (logError) {
-            // 日志获取失败不影响主流程
           }
-        }
-        if (!building) {
-          spinner.stop();
-          const totalSeconds = Math.floor((Date.now() - buildStartTime) / 1000);
-          const min = Math.floor(totalSeconds / 60);
-          const sec = totalSeconds % 60;
-          const timeStr = min > 0 ? `${min}分${sec}秒` : `${sec}秒`;
-          if (buildInfo.result === 'SUCCESS') {
-            console.log(chalk.green('🎉 Jenkins构建成功!'));
-            console.log(chalk.green(`⏱️ 总用时: ${timeStr}`));
-          } else {
-            console.log(chalk.red(`❌ Jenkins构建失败: ${buildInfo.result}`));
-            console.log(chalk.red(`⏱️ 总用时: ${timeStr}`));
+          if (!building) {
+            clearInterval(timer);
+            const total = formatTime(Date.now() - buildStartTime);
+            if (buildInfo.result === 'SUCCESS') {
+              spinner.succeed(chalk.green('构建成功') + chalk.dim(` ${total}`));
+            } else {
+              spinner.fail(chalk.red(`构建失败 ${buildInfo.result}`) + chalk.dim(` ${total}`));
+            }
+            break;
           }
-          break;
+        } catch (e) {
+          // 请求失败不影响主流程
         }
-      } catch (e) {
-        spinner.text = 'Jenkins构建中...';
+        await new Promise(r => setTimeout(r, 500));
       }
-      await new Promise(r => setTimeout(r, 500)); // 500ms刷新一次
+    } finally {
+      clearInterval(timer);
     }
   }
 }