daodou-command 1.0.0

package/.daodourc

@@ -0,0 +1,28 @@
+{
+  build: {
+    // Jenkins 基础配置
+    jenkinsUrl: 'your-jenkins-url',
+    jenkinsBase: 'your-jenkins-base',
+    jenkinsToken: 'your-jenkins-token',
+    jenkinsUsername: 'your-jenkins-username',
+    jenkinsPassword: 'your-jenkins-password',
+    
+    // 构建任务配置
+    jobName: 'my-project-test',  // 必须配置的任务名称
+    
+    // 构建参数配置
+    buildParams: {
+      token: 'your-jenkins-token',
+      BUILD_ENV: 'test',
+      version: '0.0.1'
+    }
+  },
+  lang: {
+    defaultLang: 'en',
+    defaultDir: './public/locales',
+    fileName: 'common.json',
+    // 代理相关配置
+    proxyListUrl: 'https://free-proxy-list.net/',
+    proxyTestUrl: 'https://httpbin.org/ip'
+  },
+}

package/README.md

@@ -0,0 +1,122 @@
+# 刀豆命令行工具 (Daodou CLI)
+
+一个功能强大的命令行工具，支持自动化构建和多语言管理。
+
+## 安装
+
+```bash
+npm install -g daodou-command
+```
+
+## 功能特性
+
+### 🚀 构建功能
+- 自动检测Git分支
+- 一键触发Jenkins构建
+- 实时监听构建进度
+
+### 🌐 多语言管理
+- 支持多语言文件管理
+- 自动翻译功能（Google Translate API）
+- 多代理轮换绕过API限制
+
+## 快速开始
+
+### 构建项目
+```bash
+# 在项目根目录下执行
+cd your-project
+dao build
+```
+
+### 多语言管理
+```bash
+# 添加多语言项（自动翻译）
+dao lang add "hello world"
+
+# 添加多语言项（指定值）
+dao lang add "welcome" "欢迎"
+
+# 删除多语言项
+dao lang remove "hello world"
+```
+
+## 配置
+
+首次运行会自动生成 `.daodourc` 配置文件：
+
+```json5
+{
+  build: {
+    jenkinsUrl: 'your-jenkins-url',
+    jenkinsBase: 'your-jenkins-base',
+    jenkinsToken: 'your-jenkins-token',
+    jenkinsUsername: 'your-username',
+    jenkinsPassword: 'your-password',
+    jobName: 'your-job-name',
+
+    buildParams: {
+      token: 'your-jenkins-token',
+      BUILD_ENV: 'test',
+      version: '0.0.1'
+    }
+  },
+  
+  lang: {
+    defaultLang: 'en',
+    defaultDir: './public/locales',
+    fileName: 'common.json'
+  }
+}
+```
+
+## 命令用法
+
+### 构建命令
+```bash
+dao build                    # 自动检测分支并构建
+dao build --branch feature   # 指定分支构建
+dao build --help            # 查看帮助
+```
+
+### 多语言命令
+```bash
+dao lang add "key" "value"   # 添加多语言项
+dao lang remove "key"        # 删除多语言项
+dao lang add "key" --lang zh # 只处理特定语言
+dao lang --help             # 查看帮助
+```
+
+## 多语言文件结构
+
+工具会自动扫描 `/public/locales/[lang]/common.json` 文件：
+
+```
+public/
+└── locales/
+    ├── en/
+    │   └── common.json
+    ├── zh/
+    │   └── common.json
+    └── ja/
+        └── common.json
+```
+
+## 常见问题
+
+- **Jenkins配置**: 请编辑 `.daodourc` 文件，填写真实的Jenkins配置
+- **多语言目录**: 工具会提示目录不存在，不会自动创建
+- **翻译失败**: 工具会自动重试和切换代理
+
+## 开发
+
+```bash
+git clone <repository-url>
+cd daodou-command
+npm install
+npm link
+```
+
+---
+
+**刀豆团队** - 让开发更简单 🚀

package/bin/daodou.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+
+const { Command } = require('commander');
+const chalk = require('chalk');
+const buildCommand = require('../lib/commands/build');
+const langCommand = require('../lib/commands/lang');
+
+const program = new Command();
+
+// 设置程序信息
+program
+  .name('dao')
+  .description('刀豆命令行工具 - 自动化构建和部署')
+  .version('1.0.0', '-v, --version');
+
+// 添加 build 命令
+program
+  .command('build')
+  .description('构建项目 - 自动检测Git分支并调用Jenkins打包')
+  .option('-j, --jenkins-url <url>', 'Jenkins服务器地址')
+  .option('-u, --username <username>', 'Jenkins用户名')
+  .option('-t, --token <token>', 'Jenkins API Token')
+  .option('-j, --job-name <name>', 'Jenkins任务名称')
+  .option('-b, --branch <branch>', '指定分支名称（默认从Git自动检测）')
+  .option('-p, --parameters <params>', '额外的构建参数 (JSON格式)')
+  .action(async (options) => {
+    try {
+      await buildCommand.execute(options);
+    } catch (error) {
+      console.error(chalk.red('构建失败:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// 添加 lang 命令
+const langCmd = program
+  .command('lang')
+  .description('多语言文件管理工具');
+
+langCmd
+  .command('add <key> [value]')
+  .description('添加多语言项')
+  .option('-l, --lang <language>', '指定语言（如 en、zh、ja）')
+  .option('-d, --dir <directory>', '指定目录（默认为 ./public/locales）')
+  .action(async (key, value, options) => {
+    try {
+      await langCommand.add(key, value, options);
+    } catch (error) {
+      console.error(chalk.red('添加失败:'), error.message);
+      process.exit(1);
+    }
+  });
+
+langCmd
+  .command('remove <key>')
+  .description('删除多语言项')
+  .option('-l, --lang <language>', '指定语言（如 en、zh、ja）')
+  .option('-d, --dir <directory>', '指定目录（默认为 ./public/locales）')
+  .action(async (key, options) => {
+    try {
+      await langCommand.remove(key, options);
+    } catch (error) {
+      console.error(chalk.red('删除失败:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// 添加帮助信息
+program.addHelpText('after', `
+示例:
+  $ dao build                                    # 自动检测Git分支并构建
+  $ dao build --branch feature/new-feature      # 指定分支构建
+  $ dao build --jenkins-url http://jenkins.example.com
+  $ dao build --parameters '{"param1":"value1"}'
+  
+  $ dao lang add "hello"
+  $ dao lang add "hello" "Hello World"
+  $ dao lang add "world" --lang en
+  $ dao lang add "测试" --dir ./i18n
+  $ dao lang remove "hello"
+  $ dao lang remove "world" --lang en
+
+注意:
+  - build 命令会自动检测当前Git分支，无需手动指定
+  - 如需指定特定分支，请使用 --branch 参数
+  - 确保在Git仓库目录中运行 build 命令
+
+环境变量:
+  JENKINS_URL      Jenkins服务器地址
+  JENKINS_USERNAME Jenkins用户名
+  JENKINS_TOKEN    Jenkins API Token
+  JENKINS_JOB_NAME Jenkins任务名称
+`);
+
+// 解析命令行参数
+program.parse(); 

package/lib/commands/build.js

@@ -0,0 +1,423 @@
+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');
+const { BrowserAuth } = require('../utils/browser');
+const { ConfigManager } = require('../utils/config');
+const axios = require('axios');
+const os = require('os');
+
+// 配置管理类，负责加载、校验、创建配置文件
+class BuildConfigManager {
+  constructor() {
+    this.configManager = new ConfigManager();
+    this.localConfig = {};
+  }
+
+  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('🔄 填写完成后请重新运行命令');
+        process.exit(0);
+      }
+      
+      this.loadConfig();
+      this.checkTemplateValues();
+    } catch (e) {
+      console.error('❌ 读取配置文件失败，请检查文件格式或内容是否正确。');
+      process.exit(1);
+    }
+  }
+
+  loadConfig() {
+    this.localConfig = this.configManager.getBuildConfigWithDefault();
+  }
+
+  checkTemplateValues() {
+    const templateValues = [
+      'your-jenkins-url',
+      'your-jenkins-base',
+      'your-jenkins-token',
+      'your-jenkins-username',
+      'your-jenkins-password'
+    ];
+    const hasTemplateValues = Object.values(this.localConfig).some(value => templateValues.includes(value));
+    if (hasTemplateValues) {
+      console.log(chalk.yellow('⚠️ 检测到配置文件包含模板值，请修改以下变量：'));
+      Object.entries(this.localConfig).forEach(([key, value]) => {
+        if (templateValues.includes(value)) {
+          console.log(chalk.cyan(`   ${key}=${value}`));
+        }
+      });
+      console.log(chalk.green('📍 文件位置：' + this.configManager.projectConfigFile));
+      console.log(chalk.cyan('🔄 修改完成后请重新运行命令'));
+      process.exit(0);
+    }
+  }
+
+  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('❌ 配置信息缺失，请检查以下配置：');
+      missingKeys.forEach(key => {
+        console.error(`   - ${key}`);
+      });
+      console.error('\n💡 提示：');
+      console.error('   1. 请在项目配置文件 (.daodourc) 中取消注释并填写上述配置');
+      if (missingKeys.includes('jobName')) {
+        console.error('   2. jobName 参数必须从本地配置文件设置，不能使用全局配置');
+      } else {
+        console.error('   2. 或者确保全局配置文件 (~/.daodou/config.json) 中包含这些配置');
+      }
+      console.error('   3. 项目配置优先于全局配置');
+      process.exit(1);
+    }
+    
+    // 验证构建参数配置
+    if (this.localConfig.buildParams) {
+      const buildParams = this.localConfig.buildParams;
+      if (typeof buildParams !== 'object') {
+        console.error('❌ buildParams 必须是对象格式');
+        process.exit(1);
+      }
+    }
+  }
+}
+
+class BuildCommand {
+  constructor() {
+    this.configManager = new BuildConfigManager();
+    this.browserAuth = new BrowserAuth();
+    this.jenkinsConfig = {
+      baseUrl: null,
+      auth: null
+    };
+  }
+
+  async execute(options = {}) {
+    // 配置检查与加载
+    this.configManager.checkAndCreateConfig();
+    this.configManager.validateConfig();
+    const config = this.configManager.localConfig;
+    this.jenkinsConfig.baseUrl = config.jenkinsUrl;
+    this.jenkinsBase = config.jenkinsBase;
+    this.jenkinsToken = config.jenkinsToken;
+    console.log(chalk.blue('🔧 刀豆构建工具启动中...\n'));
+
+    // 1. 获取分支名称（强制从Git获取，不依赖配置）
+    const branch = await this.getBranch(options);
+    console.log(chalk.green(`✅ 当前分支: ${chalk.cyan(branch)}\n`));
+
+    // 2. 浏览器登录Jenkins
+    await this.browserAuth.ensureLogin();
+
+    // 3. 设置Jenkins认证
+    this.setupJenkinsAuth();
+
+    // 4. 检查 Jenkins 会话有效性
+    await this.ensureJenkinsSession();
+
+    // 5. 构建任务名称和URL
+    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}`);
+    Object.entries(params).forEach(([key, value]) => {
+      if (key === 'token') return; // 不显示 token
+      console.log(`  ${chalk.cyan(key)}: ${chalk.magenta(value)}`);
+    });
+
+    await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'confirm',
+        message: chalk.yellow('按回车确认开始构建，Ctrl+C 取消...'),
+        default: undefined,
+        transformer: () => ''
+      }
+    ]);
+    // 只要不是 Ctrl+C 终止就继续
+
+    // 8. 记录本地计时起点
+    const buildStartTime = Date.now();
+    // 9. 触发Jenkins构建并监听进度
+    await this.triggerAndMonitorBuild(jobName, params, buildStartTime);
+  }
+
+  /**
+   * 构建任务名称
+   */
+  buildJobName(config) {
+    return config.jobName;
+  }
+
+  /**
+   * 构建任务URL
+   */
+  buildJobUrl(config, jobName) {
+    // 使用默认拼接方式
+    return `${this.jenkinsBase}/${encodeURIComponent(jobName)}/buildWithParameters`;
+  }
+
+  /**
+   * 构建参数
+   */
+  buildParams(config, branch) {
+    const buildParams = config.buildParams || {
+      token: this.jenkinsToken,
+      GIT_BRANCH: branch
+    };
+
+    // 确保 GIT_BRANCH 参数使用当前分支
+    const finalParams = { ...buildParams };
+    finalParams.GIT_BRANCH = branch;
+    
+    return finalParams;
+  }
+
+  /**
+   * 获取分支名称（强制从Git获取）
+   * @param {Object} options 命令行选项
+   * @returns {Promise<string>} 分支名称
+   */
+  async getBranch(options) {
+    // 如果命令行指定了分支，优先使用命令行参数
+    if (options.branch) {
+      console.log(chalk.yellow(`⚠️ 使用命令行指定的分支: ${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();
+    try {
+      const branch = await getCurrentBranch();
+      spinner.succeed('分支检测完成');
+      return branch;
+    } catch (error) {
+      spinner.fail('分支检测失败');
+      throw new Error(`无法检测当前分支: ${error.message}`);
+    }
+  }
+
+  setupJenkinsAuth() {
+    // 使用浏览器获取的cookies进行认证
+    const cookies = this.browserAuth.cookies;
+    const cookieString = cookies.map(c => `${c.name}=${c.value}`).join('; ');
+    this.jenkinsConfig.auth = {
+      headers: {
+        Cookie: cookieString,
+        'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36'
+      }
+    };
+  }
+
+  async ensureJenkinsSession() {
+    // 先用当前 cookie 访问 Jenkins 首页，确认是否有效
+    const cookieString = this.browserAuth.cookies
+      ? this.browserAuth.cookies.map(c => `${c.name}=${c.value}`).join('; ')
+      : '';
+    try {
+      const resp = await axios.get(this.jenkinsConfig.baseUrl, {
+        headers: {
+          Cookie: cookieString,
+          'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36'
+        },
+        maxRedirects: 0,
+        validateStatus: s => s < 400 || s === 401 || s === 403 || s === 302
+      });
+      // 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('未登录');
+      // 其它情况视为已登录
+      return true;
+    } catch (e) {
+      // 自动重新登录
+      console.log(chalk.yellow('⚠️ Cookie 已失效，自动重新登录...'));
+      await this.browserAuth.login();
+      this.setupJenkinsAuth();
+      return true;
+    }
+  }
+
+  async triggerAndMonitorBuild(jobName, params, buildStartTime) {
+    // 1. 触发构建
+    const spinner = ora('正在触发Jenkins构建...').start();
+    try {
+      const queueId = await this.triggerBuild(jobName, params);
+      spinner.succeed(chalk.green(`✅ Jenkins构建已触发，队列号: ${queueId}`));
+      // 2. 监听队列，获取build number
+      await this.monitorQueueAndBuild(jobName, queueId, buildStartTime);
+    } catch (error) {
+      spinner.fail('❌ Jenkins构建触发失败');
+      console.error(chalk.red('构建失败:'), error.message);
+    }
+  }
+
+  async triggerBuild(jobName, params) {
+    try {
+      const url = `${this.jenkinsConfig.baseUrl}job/${encodeURIComponent(jobName)}/buildWithParameters`;
+      let headers = { ...this.jenkinsConfig.auth.headers };
+      // 1. 获取 crumb（防止 403）
+      try {
+        const crumbResp = await axios.get(`${this.jenkinsConfig.baseUrl}crumbIssuer/api/json`, {
+          headers,
+          timeout: 10000
+        });
+        const { crumb, crumbRequestField } = crumbResp.data;
+        headers[crumbRequestField] = crumb;
+      } catch (e) {
+        // 如果 crumb 获取失败，继续尝试（部分 Jenkins 关闭了 CSRF 防护）
+      }
+      // 2. 触发构建
+      const response = await axios.post(url, null, {
+        headers,
+        params: params,
+        timeout: 30000
+      });
+      if (response.status === 201) {
+        // 从响应头中获取队列ID
+        const location = response.headers.location;
+        const queueId = location ? location.replace(/\/$/, '').split('/').pop() : null;
+        if (!queueId) {
+          console.log(chalk.yellow('⚠️ 未能正确获取队列号，可能是Jenkins配置问题。'));
+        }
+        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();
+    let buildNumber = null;
+    let count = 0;
+    while (!buildNumber && count < 60) { // 最多等2分钟
+      try {
+        const response = await axios.get(`${this.jenkinsConfig.baseUrl}queue/item/${queueId}/api/json`, {
+          ...this.jenkinsConfig.auth,
+          timeout: 10000
+        });
+        const item = response.data;
+        if (item.executable && item.executable.number) {
+          buildNumber = item.executable.number;
+          spinner.succeed(chalk.green(`✅ 已分配构建号: ${buildNumber}`));
+          break;
+        }
+        spinner.text = '等待Jenkins分配构建号...';
+      } catch (e) {
+        spinner.text = '队列查询中...';
+      }
+      await new Promise(r => setTimeout(r, 2000));
+      count++;
+    }
+    if (!buildNumber) {
+      spinner.fail('❌ 超时未分配构建号');
+      return;
+    }
+    // 监听构建进度
+    await this.monitorBuild(jobName, buildNumber, buildStartTime);
+  }
+
+  async monitorBuild(jobName, buildNumber, buildStartTime) {
+    const spinner = ora({
+      text: 'Jenkins构建中... [BUILDING] 0s',
+      spinner: 'dots'
+    }).start();
+    let building = true;
+    let lastLog = '';
+    let lastLogTime = 0;
+    while (building) {
+      try {
+        const response = await axios.get(`${this.jenkinsConfig.baseUrl}job/${encodeURIComponent(jobName)}/${buildNumber}/api/json`, {
+          ...this.jenkinsConfig.auth,
+          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 axios.get(`${this.jenkinsConfig.baseUrl}job/${encodeURIComponent(jobName)}/${buildNumber}/consoleText`, {
+              ...this.jenkinsConfig.auth,
+              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;
+            }
+            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}`));
+          }
+          break;
+        }
+      } catch (e) {
+        spinner.text = 'Jenkins构建中...';
+      }
+      await new Promise(r => setTimeout(r, 500)); // 500ms刷新一次
+    }
+  }
+}
+
+module.exports = new BuildCommand();