/tdx-publish [--pack|--only-pack] 模板文件 模块 分支 commit 版本 [模块 分支 commit 版本]...

/tdx-publish CCGR-native-beta.txt tdxtoolutil master eb00aa81 2.18.0

/tdx-publish --pack CCGR-native-beta.txt tdxtoolutil master eb00aa81 2.18.0

工程=AppCCGR        # AppCCGR / AppXNZQ_SDK / AppHBZQ
分支=成长层新框架   # App 工程分支
类型=Appbeta        # Appbeta / AppRelease / 两者都更新
定义ID=403          # TFS 构建定义 ID

/tdx-publish CCGR-native-beta.txt \
   tdxtoolutil master eb00aa81 2.18.0 \
   tdxjyframingmodule master_ccgr d63dff46 2.18.0

/tdx-publish --pack CCGR-native-beta.txt \
   tdxtoolutil master eb00aa81 2.18.0 \
   tdxjyframingmodule master_ccgr d63dff46 2.18.0

/tdx-publish --only-pack

工程=AppCCGR        # AppCCGR / AppXNZQ_SDK / AppHBZQ
分支=成长层新框架   # App 工程分支
类型=Appbeta        # Appbeta / AppRelease / 两者都更新
定义ID=403          # TFS 构建定义 ID

模块版本（每行一个）：
tdxCore=2.18.0-2504081234
tdxtoolutil=2.18.0-2504081235

all, tdxtoolutil, tdxCore, tdxCoreSo, tdxframework,
tdxfragmentandactivityutil, tdxHQ, tdxhqdg, tdxhqgg,
tdxjyframingmodule, tdxoemhqmodule, tdxoemjymodule, tdxweex

undefined

**Jenkins 连接验证（使用 session cookie + CRUMB）：**
```bash

**验证失败时 → 清除无效凭据，重新执行 Step 0a 询问用户**

git --version

undefined

undefined

undefined

然后输出配置选择提示：

**用户回复后，保存配置供后续使用：**
- APP_REPO（工程名）
- APP_BRANCH（分支名）
- BUILD_TYPE（Appbeta/AppRelease/两者都更新）
- DEFINITION_ID（构建定义ID）

**⚠️ 注意：AAR 发布完成后，必须先更新 build.gradle 并提交，再触发 TFS 构建！**

---

// 注释行
tdxCore,master,abc123def,old_commit_hash
tdxHQ,master,xyz789,old_commit_hash

前置检查
├─ 0a. 检测凭据 → 缺失时询问用户 → 保存到 .env
├─ 0b. 验证凭据有效性
├─ 0c. 检测 Git 工具可用
├─ 0d. 检测 Node.js 环境（--pack 参数必需）
└─ 0e. 如果有 --pack 参数 → 立即询问打包配置并保存
      ↓
1. 克隆 FlutterBuild 仓库
   - Bash: git clone http://192.168.40.200:8080/tfs/OpenSDK/_git/FlutterBuild
   - 认证: 使用 TFS_USER:TFS_PASSWORD
      ↓
2. 搜索模板文件
   - Glob: 在仓库中搜索匹配 template_file
   - 支持路径: QS_Android/*.txt, TDX_Android/*.txt, *.txt
      ↓
3. 读取模板内容
   - Read: 读取模板文件
      ↓
4. 解析模板
   - 找到 module 对应行
   - 格式: module,branch,commit,old_commit
      ↓
5. 更新模板
   - Edit: 替换该行的 commit 为新值
   - 格式: module,branch,new_commit,old_commit
      ↓
6. Git 提交
   - Bash: git add, git commit, git push
   - commit message: "更新 {module} 到 {new_commit}"
      ↓
7. 触发 Jenkins 构建
   - Bash curl: 调用 Jenkins API（session + CRUMB）
   - POST /job/QS_Android/buildWithParameters
   - 参数: FILENAME, Module, VERSION
      ↓
8. 轮询构建状态
   - 循环调用 Jenkins API 查询状态
   - 间隔: 10秒，最长: 30分钟
   - 状态: SUCCESS / FAILURE / BUILDING
      ↓
9. 获取构建结果
   - 提取 AAR 下载链接
      ↓
10. 如果有 --pack 参数（配置已在 Step 0e 收集）
    └─ 执行 Step P2-P4 更新 App 工程
      ↓
11. 返回结果给用户

undefined

undefined

// 使用 Glob 工具搜索
pattern: "**/*CCGR-native-beta.txt"

// 使用 Bash 工具读取文件（保持原始编码）
// ⚠️ 重要：不要用 Read 工具，它会改变文件编码！
cat /tmp/FlutterBuild/QS_Android/CCGR-native-beta.txt

undefined

**⚠️ 编码保护原则：**
1. **不要使用 Read 工具读取文件** - 它会改变编码
2. **使用 Bash + cat/sed 处理文件** - 保持原始字节
3. **只修改 ASCII 部分**（模块配置行），不动中文注释
4. **提交前用 git diff 确认** 只改了预期的行

undefined

**注意：Windows 环境 Git Bash 需要额外处理：**
```bash

undefined

undefined

if echo "$BUILD_INFO" | grep -q '"Module"'; then
  MODULE_NAME=$(echo "$BUILD_INFO" | grep -o '"Module":"[^"]*"' | cut -d'"' -f4)
  BUILD_RESULT=$(echo "$BUILD_INFO" | grep -o '"result":"[^"]*"' | cut -d'"' | head -1)
  BUILDING=$(echo "$BUILD_INFO" | grep -o '"building":[^,]*' | cut -d':' -f2)

  echo "构建 #${build_num} (${MODULE_NAME}): building=${BUILDING}, result=${BUILD_RESULT:-进行中}"
fi

**多模块构建监控正确做法：**
1. 记录触发前的 `lastBuild` 编号
2. 触发所有模块构建
3. 扫描新创建的构建（编号 > lastBuild），匹配 Module 参数
4. 分别追踪每个构建的状态

// 使用 Write 工具
file_path: logs/2026-04-07.jsonl
content: {
  "timestamp": "2026-04-07T12:00:00Z",
  "template_file": "CCGR-native-beta.txt",
  "module": "tdxCore",
  "commit": "new456",
  "jenkins_build": 145,
  "status": "success"
}

{
  "success": true,
  "template_file": "CCGR-native-beta.txt",
  "module": "tdxCore",
  "commit": "a1b2c3d4",
  "jenkins": {
    "build_number": 145,
    "build_url": "http://jenkins/job/xxx/145/",
    "apk_url": "..."
  }
}

{
  "success": false,
  "error_code": "E-JEN-05",
  "error_message": "Jenkins 构建失败"
}

{
  "records": [
    {"template_file": "CCGR-native-beta.txt", "module": "tdxCore", "branch": "master", "commit": "abc123"},
    {"template_file": "CCGR-native-beta.txt", "module": "tdxTrade", "branch": "master", "commit": "def456"}
  ]
}

═════════════════════════════════════════════════════════════════
📦 仅打包模式（AAR 已发布），请确认以下信息：
═════════════════════════════════════════════════════════════════

请回复以下信息：

工程=AppCCGR        # 必填：AppCCGR / AppXNZQ_SDK / AppHBZQ
分支=成长层新框架   # 必填：App 工程的分支名
类型=Appbeta        # 必填：Appbeta 或 AppRelease 或 两者都更新
定义ID=403          # 必填：TFS 构建定义 ID

模块版本（每行一个，格式：模块名=版本号）：
tdxCore=2.18.0-2504081234
tdxtoolutil=2.18.0-2504081235

💡 build.gradle 依赖格式示例：
   compile(group: 'tdx.android.aar', name: 'tdxCore_master_2025', version: '2.18.0-2504081234', ext: 'aar')
   更新时会匹配 name 中的模块名，替换 version 值

═════════════════════════════════════════════════════════════════

undefined

undefined

undefined

undefined

compile(group: 'tdx.android.aar', name: 'tdxCore_master_2025', version: '2.14-2508201123', ext: 'aar', changing: true)

undefined

undefined

git add AppAndroid/${BUILD_TYPE}/app/build.gradle
git commit -m "更新 ${MODULES} AAR 版本到 ${VERSION}"
git push

undefined

**Step P5-2: 创建 TFS 构建脚本**

使用 Write 工具创建临时脚本 `/tmp/tfs-build.js`：

```javascript
// 使用 Write 工具创建以下内容
const { NtlmClient } = require('axios-ntlm');

// 从命令行参数获取配置
const TFS_URL = process.argv[2];       // TFS服务器URL
const COLLECTION = process.argv[3];    // 集合名（OpenSDK）
const PROJECT = process.argv[4];       // 工程名
const USERNAME = process.argv[5];      // 用户名
const PASSWORD = process.argv[6];      // 密码
const DEFINITION_ID = parseInt(process.argv[7]); // 构建定义ID
const BRANCH = process.argv[8];        // 分支名

// 解析域名（如果用户名格式为 domain\username）
let domain = '';
let username = USERNAME;
if (USERNAME.includes('\\')) {
  const parts = USERNAME.split('\\');
  domain = parts[0];
  username = parts[1];
}

// 创建 NTLM 客户端
const ntlmClient = NtlmClient({
  username,
  password: PASSWORD,
  domain,
  workstation: ''
});

// 构建请求体（关键：sourceBranch 参数）
const buildRequest = {
  definition: {
    id: DEFINITION_ID
  },
  sourceBranch: BRANCH.startsWith('refs/heads/') ? BRANCH : `refs/heads/${BRANCH}`
};

// 尝试多种 API 版本和 URL 格式
const urls = [
  `${TFS_URL}/tfs/${COLLECTION}/${PROJECT}/_apis/build/builds?api-version=2.0`,
  `${TFS_URL}/tfs/${COLLECTION}/${PROJECT}/_apis/build/builds?api-version=4.1`,
  `${TFS_URL}/tfs/${COLLECTION}/${PROJECT}/_apis/build/builds?api-version=5.0`,
  `${TFS_URL}/tfs/DefaultCollection/${PROJECT}/_apis/build/builds?api-version=2.0`,
];

async function triggerBuild() {
  console.log(`触发构建: ${PROJECT}, 分支: ${BRANCH}, 定义ID: ${DEFINITION_ID}`);
  console.log(`请求体: ${JSON.stringify(buildRequest)}`);

  for (let i = 0; i < urls.length; i++) {
    const url = urls[i];
    console.log(`尝试 URL ${i + 1}: ${url}`);
    try {
      const response = await ntlmClient.post(url, buildRequest);
      console.log(`✅ 成功!`);
      console.log(`构建ID: ${response.data.id}`);
      console.log(`构建号: ${response.data.buildNumber}`);
      console.log(`状态: ${response.data.status}`);
      console.log(`分支: ${response.data.sourceBranch}`);
      console.log(`---SUCCESS---`);
      return;
    } catch (e) {
      console.log(`失败: ${e.response?.status || e.message}`);
    }
  }
  console.log(`❌ 所有 URL 都失败`);
  console.log(`---FAILED---`);
}

triggerBuild().catch(e => console.error(e));

undefined

**Step P5-4: 解析输出判断结果**

脚本输出包含：
- `---SUCCESS---` 表示成功触发
- `构建ID: xxx` 用于后续状态查询
- `构建号: xxx` 用于日志追踪
- `分支: refs/heads/xxx` 确认实际构建分支
- `---FAILED---` 表示触发失败

**如果触发成功，继续监控构建状态：**

**Step P6-1: 创建状态查询脚本**

```javascript
// 使用 Write 工具创建 /tmp/tfs-status.js
const { NtlmClient } = require('axios-ntlm');

const TFS_URL = process.argv[2];
const COLLECTION = process.argv[3];
const PROJECT = process.argv[4];
const USERNAME = process.argv[5];
const PASSWORD = process.argv[6];
const BUILD_ID = process.argv[7];

let domain = '';
let username = USERNAME;
if (USERNAME.includes('\\')) {
  const parts = USERNAME.split('\\');
  domain = parts[0];
  username = parts[1];
}

const ntlmClient = NtlmClient({ username, password: PASSWORD, domain, workstation: '' });

const urls = [
  `${TFS_URL}/tfs/${COLLECTION}/${PROJECT}/_apis/build/builds/${BUILD_ID}?api-version=5.0`,
  `${TFS_URL}/tfs/DefaultCollection/${PROJECT}/_apis/build/builds/${BUILD_ID}?api-version=5.0`,
];

async function getStatus() {
  for (const url of urls) {
    try {
      const response = await ntlmClient.get(url);
      const data = response.data;
      console.log(`状态: ${data.status}`);
      console.log(`结果: ${data.result || '进行中'}`);
      console.log(`构建号: ${data.buildNumber}`);
      console.log(`分支: ${data.sourceBranch}`);
      if (data.status === 'completed') {
        console.log(`---COMPLETED---`);
      } else {
        console.log(`---IN_PROGRESS---`);
      }
      return;
    } catch (e) {
      console.log(`尝试失败: ${e.message}`);
    }
  }
  console.log(`---FAILED---`);
}

getStatus().catch(e => console.error(e));

undefined

**Step P6-3: 构建监控（带系统弹框提示）**

**⚠️ 创建完整监控脚本（支持弹框提示）：**

```javascript
// 使用 Write 工具创建 tfs-poll.js
const { NtlmClient } = require('axios-ntlm');
const { exec } = require('child_process');

const TFS_URL = process.argv[2];
const COLLECTION = process.argv[3];
const PROJECT = process.argv[4];
const USERNAME = process.argv[5];
const PASSWORD = process.argv[6];
const BUILD_ID = process.argv[7];
const POLL_INTERVAL = parseInt(process.argv[8]) || 30000;

let domain = '', username = USERNAME;
if (USERNAME.includes('\\')) {
  const parts = USERNAME.split('\\');
  domain = parts[0];
  username = parts[1];
}

const ntlmClient = NtlmClient({ username, password: PASSWORD, domain, workstation: '' });

// Windows 弹框 (使用 mshta)
function showAlert(title, message) {
  const cleanMsg = message.replace(/[\r\n]/g, ' ').replace(/"/g, "'");
  const cleanTitle = title.replace(/"/g, "'");
  exec(`mshta vbscript:Execute("msgbox \\"${cleanMsg}\\",64,\\"${cleanTitle}\\"(window.close)")`);
}

// 提示音
function beep(success) {
  if (success) {
    exec('powershell -Command "[console]::Beep(1000, 300); [console]::Beep(1500, 300)"');
  } else {
    exec('powershell -Command "[console]::Beep(300, 500)"');
  }
}

async function checkStatus() {
  const urls = [
    `${TFS_URL}/tfs/${COLLECTION}/${PROJECT}/_apis/build/builds/${BUILD_ID}?api-version=2.0`,
    `${TFS_URL}/tfs/DefaultCollection/${PROJECT}/_apis/build/builds/${BUILD_ID}?api-version=2.0`,
  ];
  for (const url of urls) {
    try {
      return (await ntlmClient.get(url)).data;
    } catch (e) {}
  }
  return null;
}

async function monitor() {
  console.log(`监控构建 #${BUILD_ID}...`);
  let startTime = Date.now();

  while (true) {
    const data = await checkStatus();
    if (!data) {
      console.log('无法获取状态，重试...');
      await new Promise(r => setTimeout(r, POLL_INTERVAL));
      continue;
    }

    const elapsed = Math.floor((Date.now() - startTime) / 1000);
    const mins = Math.floor(elapsed / 60), secs = elapsed % 60;
    console.log(`[${new Date().toLocaleTimeString()}] ${data.status} | ${data.result || 'running'} | ${mins}m${secs}s`);

    if (data.status === 'completed') {
      const isSuccess = data.result === 'succeeded';
      const branch = (data.sourceBranch || '').replace('refs/heads/', '');

      console.log(isSuccess ? '\n✅ 构建成功!' : '\n❌ 构建失败!');
      console.log(`构建号: ${data.buildNumber}, 分支: ${branch}, 用时: ${mins}m${secs}s`);

      // 弹框提示
      showAlert(isSuccess ? 'TFS Build Success' : 'TFS Build Failed',
        `Build ${data.buildNumber} ${data.result}. Branch: ${branch}. Time: ${mins}m${secs}s`);
      beep(isSuccess);

      process.exit(isSuccess ? 0 : 1);
    }
    await new Promise(r => setTimeout(r, POLL_INTERVAL));
  }
}
monitor().catch(e => { console.error('错误:', e.message); process.exit(1); });

undefined

**监控输出示例：**

**⚠️ 构建完成后会自动弹出系统对话框提示！**

**获取构建定义列表（验证配置）：**

**创建定义列表查询脚本：**

```javascript
// 使用 Write 工具创建 /tmp/tfs-definitions.js
const { NtlmClient } = require('axios-ntlm');

const TFS_URL = process.argv[2];
const COLLECTION = process.argv[3];
const PROJECT = process.argv[4];
const USERNAME = process.argv[5];
const PASSWORD = process.argv[6];

let domain = '';
let username = USERNAME;
if (USERNAME.includes('\\')) {
  const parts = USERNAME.split('\\');
  domain = parts[0];
  username = parts[1];
}

const ntlmClient = NtlmClient({ username, password: PASSWORD, domain, workstation: '' });

const urls = [
  `${TFS_URL}/tfs/${COLLECTION}/${PROJECT}/_apis/build/definitions?api-version=2.0`,
  `${TFS_URL}/tfs/${COLLECTION}/${PROJECT}/_apis/build/definitions?api-version=4.1`,
  `${TFS_URL}/tfs/DefaultCollection/${PROJECT}/_apis/build/definitions?api-version=2.0`,
];

async function getDefinitions() {
  for (const url of urls) {
    try {
      const response = await ntlmClient.get(url);
      if (response.data.value) {
        console.log(`=== ${PROJECT} 构建定义 ===`);
        for (const def of response.data.value) {
          console.log(`ID: ${def.id}, 名称: ${def.name}`);
        }
        console.log(`---SUCCESS---`);
        return;
      }
    } catch (e) {
      console.log(`尝试失败: ${e.message}`);
    }
  }
  console.log(`---FAILED---`);
}

getDefinitions().catch(e => console.error(e));

undefined

**已知的构建定义默认分支：**

| 定义ID | 名称 | 默认分支 |
|--------|------|----------|
| 403 | 长城国瑞_Android_Beta | refs/heads/master |
| 404 | 长城国瑞_Android_Release | refs/heads/master |

**⚠️ 关键点：**
1. **必须使用 axios-ntlm 库**，curl 不支持 NTLM + sourceBranch 组合
2. sourceBranch 格式：`refs/heads/分支名` 或直接传分支名
3. 尝试多种 API 版本（2.0, 4.1, 5.0）
4. 集合名称优先使用 `OpenSDK`，备选 `DefaultCollection`

// tfs-artifacts.js - 获取构建产物
const { NtlmClient } = require('axios-ntlm');

const TFS_URL = process.argv[2];
const COLLECTION = process.argv[3];
const PROJECT = process.argv[4];
const USERNAME = process.argv[5];
const PASSWORD = process.argv[6];
const BUILD_ID = process.argv[7];

let domain = '';
let username = USERNAME;
if (USERNAME.includes('\\')) {
  const parts = USERNAME.split('\\');
  domain = parts[0];
  username = parts[1];
}

const ntlmClient = NtlmClient({ username, password: PASSWORD, domain, workstation: '' });

const urls = [
  `${TFS_URL}/tfs/${COLLECTION}/${PROJECT}/_apis/build/builds/${BUILD_ID}/artifacts?api-version=5.0`,
  `${TFS_URL}/tfs/DefaultCollection/${PROJECT}/_apis/build/builds/${BUILD_ID}/artifacts?api-version=5.0`,
];

async function getArtifacts() {
  for (const url of urls) {
    try {
      const response = await ntlmClient.get(url);
      if (response.data.value && response.data.value.length > 0) {
        const artifact = response.data.value[0];
        console.log(`产物名称: ${artifact.name}`);
        console.log(`下载链接: ${artifact.resource.downloadUrl}`);
        console.log(`---SUCCESS---`);
        return;
      }
    } catch (e) {
      console.log(`尝试失败: ${e.message}`);
    }
  }
  console.log(`---FAILED---`);
}

getArtifacts().catch(e => console.error(e));

undefined

undefined

═════════════════════════════════════════════════════════════════
✅ 打包完成！

📌 构建信息：
   • 工程：${APP_REPO}
   • 分支：${APP_BRANCH}
   • 类型：${BUILD_TYPE}
   • 构建号：#${BUILD_NUMBER}
   • 状态：${RESULT}

📦 APK 下载：
   ${APK_URL}

═════════════════════════════════════════════════════════════════

{
  "definition": { "id": 123 },
  "sourceBranch": "refs/heads/分支名"
}

undefined

---

/tdx-publish HBZQ.txt tdxCore master 6af7a8a6 6.9.5 --pack
                    │
                    ▼
┌─────────────────────────────────────────┐
│  Step 0: 前置检查                        │
│  • 检测凭据（TFS_USER/PASSWORD）         │
│  • 验证 Git / Jenkins 连接               │
│  • 检测 Node.js 环境（--pack 必需）      │
│  • 如果有 --pack → 一次性确认打包配置：   │
│    工程、分支、Appbeta/AppRelease、定义ID │
└─────────────────────────────────────────┘
                    │
                    ▼
┌─────────────────────────────────────────┐
│  Step 1-6: AAR 发布                      │
│  • 克隆 FlutterBuild                     │
│  • 更新模板文件 commit                   │
│  • Git 提交推送                          │
└─────────────────────────────────────────┘
                    │
                    ▼
┌─────────────────────────────────────────┐
│  Step 7-8: Jenkins 构建（多模块）         │
│  • 记录触发前的 lastBuild 编号           │
│  • 触发所有模块构建                      │
│  • 扫描新构建，匹配 Module 参数          │
│  • 分别追踪每个构建状态                  │
└─────────────────────────────────────────┘
                    │
                    ▼
┌─────────────────────────────────────────┐
│  Step 9: 获取构建结果                    │
│  • 从 Jenkins 日志提取 AAR 版本号        │
│  • 返回 AAR 下载链接                     │
└─────────────────────────────────────────┘
                    │
                    ▼
        ┌───────────┴───────────┐
        │   有 --pack 参数？     │
        └───────────┬───────────┘
              是 │
                 ▼
┌─────────────────────────────────────────┐
│  Step P2-P4: 更新 App 工程（重要！）      │
│  ⚠️ 必须先更新 build.gradle 再触发构建   │
│  • 克隆 App 工程（指定分支）             │
│  • 更新 build.gradle 中的 AAR 版本       │
│  • Git 提交推送                          │
└─────────────────────────────────────────┘
                    │
                    ▼
┌─────────────────────────────────────────┐
│  Step P5-P6: 触发 TFS 构建               │
│  • 使用 Node.js + axios-ntlm 库          │
│  • 创建临时脚本触发构建（支持指定分支）  │
│  • 轮询构建状态等待完成                  │
└─────────────────────────────────────────┘
                    │
                    ▼
┌─────────────────────────────────────────┐
│  ✅ 完成！                               │
│  • AAR 已发布到 Maven 仓库               │
│  • build.gradle 已更新并提交             │
│  • TFS 构建已触发（或提供手动链接）       │
└─────────────────────────────────────────┘

/tdx-publish --only-pack
                    │
                    ▼
┌─────────────────────────────────────────┐
│  Step 0: 前置检查                        │
│  • 检测凭据（TFS_USER/PASSWORD）         │
│  • 验证 Git 连接                         │
│  • 检测 Node.js 环境                     │
└─────────────────────────────────────────┘
                    │
                    ▼
┌─────────────────────────────────────────┐
│  Step O1: 询问打包配置                   │
│  • 工程、分支、类型、定义ID              │
│  • 模块名和已发布的 AAR 版本号           │
└─────────────────────────────────────────┘
                    │
                    ▼
┌─────────────────────────────────────────┐
│  Step O2-O4: 更新 App 工程               │
│  • 克隆 App 工程（指定分支）             │
│  • 更新 build.gradle 中的 AAR 版本       │
│  • Git 提交推送                          │
└─────────────────────────────────────────┘
                    │
                    ▼
┌─────────────────────────────────────────┐
│  Step O5-O6: 触发 TFS 构建               │
│  • 使用 Node.js + axios-ntlm 库          │
│  • 创建临时脚本触发构建（支持指定分支）  │
│  • 轮询构建状态等待完成                  │
│  • 系统弹框提示构建结果                  │
└─────────────────────────────────────────┘
                    │
                    ▼
┌─────────────────────────────────────────┐
│  ✅ 完成！                               │
│  • build.gradle 已更新并提交             │
│  • APK 构建完成                          │
└─────────────────────────────────────────┘

undefined

---