ai-engineering-init 1.17.0 → 1.17.1

package/.claude/hooks/skill-forced-eval.js

@@ -117,6 +117,7 @@ const instructions = `## 强制技能激活流程（必须执行）
 - skill-creator: 创建技能模板/技能脚手架/skill scaffold
 - leniu-report-scenario: 报表/报表开发/报表查询/报表导出/合计行/totalLine/汇总报表/定制报表/report_order_info/金额处理/分转元/餐次/mealtime/ReportBaseTotalVO/CustomNumberConverter
 - leniu-marketing-scenario: 营销/营销规则/消费规则/计价规则/充值规则/扣款规则/就餐规则/折扣/满减/限额/限次/补贴/赠送/满赠/管理费/MarketApi/RulePriceHandler/RuleRechargeHandler/RulePayHandler/MarketRule/规则定制
+- jenkins-deploy: 打包/部署/Jenkins/构建/Portainer/发布到dev/发布到test/更新环境/自动部署
 
 ### 步骤 2 - 激活（逐个调用，等待每个完成）
 

package/.claude/skills/jenkins-deploy/SKILL.md

@@ -0,0 +1,207 @@
+---
+name: jenkins-deploy
+description: |
+  Jenkins + Portainer 自动打包部署技能。通过 Python 脚本调用 Jenkins API 构建项目，并触发 Portainer Webhook/Update 完成容器更新。
+
+  触发场景：
+  - 需要将代码打包部署到 dev/test 环境
+  - 需要触发 Jenkins 构建 core 或 api 项目
+  - 需要更新 Portainer 容器服务
+  - 需要查看或修改构建配置（分支、环境、模式）
+  - 定制项目的打包部署
+
+  触发词：打包、部署、Jenkins、构建、Portainer、发布到dev、发布到test、更新环境、自动部署
+---
+
+# Jenkins + Portainer 自动打包部署
+
+## 概述
+
+项目使用 `jenkins/` 目录下的 Python 脚本实现自动化构建部署，流程：
+
+```
+Jenkins 构建 core → Jenkins 构建 api → Portainer 更新容器
+```
+
+## 文件位置
+
+| 文件 | 作用 |
+|------|------|
+| `jenkins/jk_build.py` | 主构建脚本 |
+| `jenkins/env_param.json` | 环境配置（Jenkins/Portainer 连接参数） |
+| `jenkins/last_cd_env.json` | 上次构建参数（自动保存） |
+
+## 构建模式
+
+| 模式 | 说明 | 执行步骤 |
+|------|------|---------|
+| `0` | 只构建 | 构建 core + api，不更新 Portainer |
+| `1` | 全构建+更新 | 构建 core + api → 触发 Portainer 更新 |
+| `2` | 构建 api+更新 | 跳过 core，构建 api → 触发 Portainer 更新 |
+| `3` | 只更新 | 不构建，直接触发 Portainer 更新 |
+
+## 环境支持
+
+| 环境 | 前缀 | Jenkins Job | Portainer |
+|------|------|-------------|-----------|
+| 开发环境 | `dev` + 编号 | `dev-tengyun-core` / `dev-tengyun-yunshitang-api` | devops-dev.xnzn.net |
+| 测试环境 | `test` + 编号 | `test-tengyun-core` / `test-tengyun-yunshitang-api` | devops-test.xnzn.net |
+| dev16+ | `dev16` ~ `dev43` | 同 dev | xnzn-dev.xnzn.net（使用 forceupdateservice） |
+| dev44+ | `dev44` 及以上 | 只支持模式 0 | 需手动更新 |
+
+## 定制项目支持
+
+当指定 `api_param_folder`（定制工程文件夹名）时，Jenkins Job 路径变为：
+
+```
+{folder_name}/dev-后端-core    # 替代 dev-tengyun-core
+{folder_name}/dev-后端-api     # 替代 dev-tengyun-yunshitang-api
+```
+
+## 使用方式
+
+### 直接运行脚本
+
+```bash
+cd jenkins && python jk_build.py
+```
+
+脚本会交互式询问：
+1. **模式**（0/1/2/3）
+2. **环境**（dev1, dev2, test1 等）
+3. **core 分支**（如 release_5.56.0）
+4. **api 分支**（如 master）
+5. **定制工程文件夹**（可选，空格或 None 跳过）
+
+### 通过 Claude 辅助部署
+
+当用户说"打包到 devX"时：
+
+1. **读取** `jenkins/last_cd_env.json` 获取上次构建参数
+2. **确认参数**：环境、分支、模式、是否定制项目
+3. **修改** `last_cd_env.json` 写入新参数
+4. **执行** `cd jenkins && python jk_build.py`（脚本读取预设值，用户直接回车即可）
+
+## 配置文件说明
+
+### last_cd_env.json（构建参数）
+
+```json
+{
+  "build_mode": "0",
+  "cd_env": "dev63",
+  "core_param_branch": "release_5.56.0",
+  "api_param_branch": "master",
+  "api_param_folder": null
+}
+```
+
+| 字段 | 说明 |
+|------|------|
+| `build_mode` | 构建模式（0/1/2/3） |
+| `cd_env` | 目标环境（如 dev1, test2） |
+| `core_param_branch` | core 仓库分支 |
+| `api_param_branch` | api 仓库分支 |
+| `api_param_folder` | 定制项目文件夹（null 表示标准项目） |
+
+### env_param.json（环境连接配置）
+
+包含 Jenkins 和 Portainer 的连接参数（用户名、API Token、服务地址等），按 dev/test 环境分组。
+
+> **注意**：此文件包含敏感凭证，不要将内容输出到对话中。
+
+## 构建流程详解
+
+```
+1. 连接 Jenkins（ci.xnzn.net）
+2. 构建 core（参数：BRANCH + VERSION=环境名）
+   └─ 轮询构建进度，超时 10 分钟
+3. 构建 api（参数同上）
+   └─ 轮询构建进度，超时 5 分钟
+4. 更新 Portainer：
+   ├─ dev1~15：Webhook 触发
+   │   └─ 获取 JWT → 查 Service ID → 获取/创建 Webhook → POST 触发
+   └─ dev16+：Force Update
+       └─ 获取 JWT → 查 Service ID → PUT forceupdateservice
+```
+
+## 常见操作
+
+### 只改了 api 代码，快速部署
+
+```bash
+# 修改 last_cd_env.json 的 build_mode 为 "2"，然后运行
+cd jenkins && python jk_build.py
+```
+
+### 只需要更新容器（已在 Jenkins 手动构建完）
+
+```bash
+# build_mode 设为 "3"
+cd jenkins && python jk_build.py
+```
+
+### 部署定制项目
+
+```json
+// last_cd_env.json
+{
+  "api_param_folder": "leniu-tengyun-wuhanxieheyiyuan"
+}
+```
+
+## 首次初始化（团队成员）
+
+当用户说"初始化部署环境"或检测到 `jenkins/` 目录不存在时，执行以下步骤：
+
+### 自动初始化流程
+
+```bash
+# 1. 创建 jenkins 目录
+mkdir -p jenkins
+
+# 2. 从技能模板复制文件（SKILL_DIR 为技能目录路径）
+cp .claude/skills/jenkins-deploy/assets/jk_build.py jenkins/jk_build.py
+cp .claude/skills/jenkins-deploy/assets/last_cd_env.template.json jenkins/last_cd_env.json
+
+# 3. 环境配置需要用户提供（含敏感凭证）
+cp .claude/skills/jenkins-deploy/assets/env_param.template.json jenkins/env_param.json
+
+# 4. 安装依赖
+pip install python-jenkins requests
+```
+
+### 配置凭证
+
+初始化后，`jenkins/env_param.json` 中的占位符需要替换为真实值：
+
+| 占位符 | 说明 | 获取方式 |
+|--------|------|---------|
+| `__JENKINS_DEV_USER__` | Jenkins dev 账号 | 向团队负责人获取 |
+| `__JENKINS_DEV_TOKEN__` | Jenkins dev API Token | Jenkins → 用户 → 设置 → API Token |
+| `__JENKINS_TEST_USER__` | Jenkins test 账号 | 同上 |
+| `__JENKINS_TEST_TOKEN__` | Jenkins test API Token | 同上 |
+| `__PORTAINER_*_USER__` | Portainer 用户名 | 向团队负责人获取 |
+| `__PORTAINER_*_PWD__` | Portainer 密码 | 向团队负责人获取 |
+
+**快捷方式**：如果团队已有成员配置好，可直接拷贝对方的 `env_param.json` 文件。
+
+### AI 初始化行为
+
+当技能被触发但 `jenkins/` 不存在时：
+1. 提示用户"检测到尚未初始化部署环境"
+2. 询问是否执行初始化
+3. 执行上述复制步骤
+4. 提示用户填写凭证（或拷贝已有配置）
+
+## 依赖
+
+```bash
+pip install python-jenkins requests
+```
+
+## 注意
+
+- 本技能用于 dev/test 环境部署，**不涉及生产环境**
+- 如果是 Git 提交/分支管理，请使用 `git-workflow` 技能
+- 如果是代码构建错误排查，请使用 `bug-detective` 技能

package/.claude/skills/jenkins-deploy/assets/env_param.template.json

@@ -0,0 +1,51 @@
+{
+  "portainer_api_url": {
+    "dev": "https://devops-dev.xnzn.net/api",
+    "dev16": "https://xnzn-dev.xnzn.net/api",
+    "test": "https://devops-test.xnzn.net/api"
+  },
+  "portainer_user_name": {
+    "dev": "__PORTAINER_DEV_USER__",
+    "dev16": "__PORTAINER_DEV16_USER__",
+    "test": "__PORTAINER_TEST_USER__"
+  },
+  "portainer_user_pwd": {
+    "dev": "__PORTAINER_DEV_PWD__",
+    "dev16": "__PORTAINER_DEV16_PWD__",
+    "test": "__PORTAINER_TEST_PWD__"
+  },
+  "portainer_endpoints": {
+    "dev": "2",
+    "dev16": "1",
+    "test": "2"
+  },
+  "portainer_server_suffix": {
+    "dev": "_yunshitang-api",
+    "dev16": "_yunshitang-api-offline",
+    "test": "_yunshitang-api"
+  },
+  "core_job": {
+    "dev": "dev-tengyun-core",
+    "test": "test-tengyun-core"
+  },
+  "core_job_custom": {
+    "dev": "dev-后端-core",
+    "test": "test-后端-core"
+  },
+  "api_job": {
+    "dev": "dev-tengyun-yunshitang-api",
+    "test": "test-tengyun-yunshitang-api"
+  },
+  "api_job_custom": {
+    "dev": "dev-后端-api",
+    "test": "test-后端-api"
+  },
+  "jenkins_user_id": {
+    "dev": "__JENKINS_DEV_USER__",
+    "test": "__JENKINS_TEST_USER__"
+  },
+  "jenkins_api_token": {
+    "dev": "__JENKINS_DEV_TOKEN__",
+    "test": "__JENKINS_TEST_TOKEN__"
+  }
+}

package/.claude/skills/jenkins-deploy/assets/jk_build.py

@@ -0,0 +1,362 @@
+# 简单调用jenkins api，构建项目并触发webhook
+import html
+import json
+import os
+import time
+
+import jenkins
+import requests
+
+# 预设默认值（可修改）
+cd_env = ''  # dev或test
+
+# dev和test环境独立配置
+jenkins_server_url = 'https://ci.xnzn.net'  # jenkins地址
+portainer_server_suffix = ''  # portainer服务名后缀
+core_timeout = 60 * 10  # core构建超时时间
+api_timeout = 60 * 5  # api构建超时时间
+portainer_user_name = ''  # portainer用户名
+portainer_user_pwd = ''  # portainer密码
+portainer_api_url = ''
+portainer_endpoints = ''
+jenkins_user_id = ''
+jenkins_api_token = ''
+core_job = ''
+api_job = ''
+
+# 执行job方法，通过等待时间来判断是否构建成功
+def do_job_by_time(server, job_name, param_branch, param_env, wait_time):
+    queue_num = server.build_job(name=job_name,
+                                 parameters={'BRANCH': param_branch, 'VERSION': param_env},
+                                 token=jenkins_api_token)
+    print('创建queue... {queue_num}')
+    time.sleep(wait_time)
+    queue_info = server.get_queue_item(queue_num)
+
+    print('等待时间到，queue信息：' + str(queue_info))
+
+
+# 执行job方法，通过请求判断结束，进度更准确
+def do_job(server, job_name, param_branch, param_env, wait_time):
+
+    queue_num = server.build_job(name=job_name,
+                                 parameters={'BRANCH': param_branch, 'VERSION': param_env},
+                                 token=jenkins_api_token)
+    print(f'创建队列... {queue_num}')
+    job_number = None
+    # 记录开始构建时间
+    start_time = time.time()
+
+    while True:
+        time.sleep(10)
+        if time.time() - start_time > wait_time:
+            print("构建超时，结束")
+            exit(1)
+        queue_info = server.get_queue_item(queue_num)
+        if queue_info['why'] is not None:
+            why = queue_info['why']
+            print(f'队列等待执行器...{why}')
+        elif 'executable' in queue_info:
+            job_number = queue_info['executable']['number']
+            print(f'开始执行任务...{job_number}')
+            break
+        else:
+            print('执行结束')
+            break
+
+    # 间隔x秒查询构建结果
+    while True:
+        time.sleep(10)
+
+        # 如果超过3分钟，直接结束
+        if time.time() - start_time > wait_time:
+            print("构建超时，结束")
+            exit(1)
+        headers = {
+            "n": str(job_number),
+        }
+        # 如果job_name包含 '/'，则在把'/'替换为/job/
+        if '/' in job_name:
+            job_name_url = job_name.replace('/', '/job/')
+            url = f'{jenkins_server_url}/job/{job_name_url}/buildHistory/ajax'
+        else:
+            url = f'{jenkins_server_url}/job/{job_name}/buildHistory/ajax'
+
+        req = requests.Request(method='POST', url=url, headers=headers)
+        response = server.jenkins_open(req)
+        # 解析response包含的html
+        html_str = html.unescape(response)
+        if 'Expected build number' in html_str:  # 正在等待中
+            print(f'\r等待中...', end='')
+            continue
+        elif ('预计剩余时间' in html_str) or ('Estimated remaining time' in html_str):  # 是否包含 预计剩余时间
+            try:
+                # 取出 '<td style="width:' 和 '%;" class="progress-bar-done"></td>' 之间的字符串
+                progress = html_str.split('<td style="width:')[1].split('%;" class="progress-bar-done"></td>')[0]
+                # 打印进度更新最后一行
+                print(f'\r构建中...{progress}%', end='')
+            except IndexError:
+                print("无法从HTML字符串中提取进度信息")
+            except Exception as e:
+                print(f"发生错误: {e}")
+            continue
+        else:
+            print(f"\r构建结束，耗时 {(time.time() - start_time):.2f} 秒", end='\n')
+            # 查询构建结果
+            build_info = server.get_build_info(job_name, job_number)
+            if build_info['result'] == 'SUCCESS':
+                print(f"构建成功 {html.unescape(build_info['url'])}")
+            else:
+                print(f"构建失败（{build_info['result']}） {html.unescape(build_info['url'])}")
+                print(f"原始 build_info：{build_info}")
+                print(f"原始 html：{html_str}")
+                return False
+            break
+    return True
+
+
+# 获取 Portainer JWT Token
+def get_jwt_token():
+    login_url = f"{portainer_api_url}/auth"
+    login_data = {
+        "Username": portainer_user_name,
+        "Password": portainer_user_pwd,
+    }
+    response = requests.post(login_url, data=json.dumps(login_data))
+    token = response.json()["jwt"]
+    print('获取token成功')
+    return token
+
+
+# 获取 Service ID
+def get_server_id(token):
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Content-Type": "application/json"
+    }
+    # Get list of services
+    # services_response = requests.get(portainer_api_url + "/endpoints/1/docker/services", headers=headers) // dev改成了2
+    url = portainer_api_url + f'/endpoints/{portainer_endpoints}/docker/services'
+    services_response = requests.get(url, headers=headers)
+    services = services_response.json()
+
+    service_name = cd_env + portainer_server_suffix
+    # Find service with matching name
+    target_service_id = None
+    for service in services:
+        if service["Spec"]["Name"] == service_name:
+            target_service_id = service["ID"]
+            break
+
+    print(f'查询{service_name}的service_id：{target_service_id}')
+    return target_service_id
+
+
+# 获取 Service 的 WebHook
+def get_service_web_hook():
+    pt_token = get_jwt_token()
+    service_id = get_server_id(pt_token)
+
+    headers = {
+        "Authorization": f"Bearer {pt_token}",
+        "Content-Type": "application/json"
+    }
+
+    # 查询service的webhook
+    # url = portainer_api_url + f'/webhooks?filters=%7B%22ResourceID%22:%22{service_id}%22,%22EndpointID%22:1%7D' // dev改成了2
+    url = portainer_api_url + f'/webhooks?filters=%7B%22ResourceID%22:%22{service_id}%22,%22EndpointID%22:{portainer_endpoints}%7D'
+    services_response = requests.get(url, headers=headers)
+    webhook_json = services_response.json()
+    target_webhook_token = None
+    # 是否存在webhook
+    if len(webhook_json) > 0:
+        target_webhook_token = webhook_json[0]['Token']
+        print('获取webhook_token：' + target_webhook_token)
+
+    #  尝试调用请求创建webhook
+    if target_webhook_token is None:
+        payload = {"ResourceID": service_id, "EndpointID": 2, "WebhookType": 1, "registryID": 0}
+        services_response = requests.post(portainer_api_url + "/webhooks", headers=headers, data=json.dumps(payload))
+        webhook_json = services_response.json()
+        if webhook_json is not None and 'Token' in webhook_json:
+            target_webhook_token = webhook_json['Token']
+        print('创建webhook_token结果：' + target_webhook_token)
+
+    return target_webhook_token
+
+
+# 启动webhook（dev1-15）
+def trigger_webhook():
+
+    wh_token = get_service_web_hook()
+
+    if wh_token is None:
+        print(f"{cd_env}环境没有配置webhook，结束")
+        exit(0)
+    else:
+        print("开始触发webhook")
+        r = requests.post(portainer_api_url + '/webhooks/' + wh_token)
+        print("webhook触发结果：" + str(r.status_code))
+
+# 通过service id 更新
+def update_portainer():
+
+    pt_token = get_jwt_token()
+    service_id = get_server_id(pt_token)
+
+    headers = {
+        "Authorization": f"Bearer {pt_token}",
+        "Content-Type": "application/json"
+    }
+
+    # 调用更新（PUT请求）：
+    url = portainer_api_url + f'/endpoints/{portainer_endpoints}/forceupdateservice'
+    payload = {
+        "serviceID": service_id,
+        "pullImage": True,
+    }
+    services_response = requests.put(url, headers=headers, data=json.dumps(payload))
+    update_rsp_json = services_response.json()
+    print('更新结果：' + str(update_rsp_json))
+
+# ~~~~~~~~~~~~~~~~~~ 开始输入 ~~~~~~~~~~~~~~~~~~~~~~~
+
+# 打印欢迎信息
+print('\n~~~~~~~~~~~~~~')
+print('正在使用jenkins+portainer构建工具，目前支持dev和test环境的自动化构建+更新')
+print('~~~~~~~~~~~~~~\n')
+
+# 获取当前目录
+current_dir = os.getcwd()
+# 读取上一次构建的环境
+with open(current_dir + '/last_cd_env.json', 'r', encoding='utf-8') as f:
+    cd_env_json = json.load(f)
+
+# 从终端获取用户输入模式
+build_mode = input(f"请输入模式 0-只构建 1-全构建+更新 2-构建api+更新 3-只更新（预设{cd_env_json['build_mode']}）：", ) or cd_env_json['build_mode']
+
+# 从终端获取用户输入cd_env
+cd_env = input(f"请输入环境（预设：{cd_env_json['cd_env']}）:", ) or cd_env_json['cd_env']
+
+# 从终端获取用户输入的分支
+core_param_branch = input(f"请输入core分支（预设：{cd_env_json['core_param_branch']}）:") or cd_env_json['core_param_branch']
+
+# 从终端输入api分支
+api_param_branch = input(f"请输入api分支（预设：{cd_env_json['api_param_branch']}）:") or cd_env_json['api_param_branch']
+
+# 从终端输入api文件夹名
+# 读取上一次构建的分支
+api_param_folder = input(f"请输入定制工程文件夹名（空格或None表示不需要，预设：{cd_env_json['api_param_folder']}）:") or cd_env_json['api_param_folder']
+
+# 校验模式：
+if build_mode is None or build_mode not in ('0', '1', '2', '3'):
+    print("模式错误，结束")
+    exit(1)
+# 校验环境，如果不是dev或test开头的，直接退出
+if cd_env is None or not cd_env.startswith('dev') and not cd_env.startswith('test'):
+    print("环境错误，结束")
+    exit(1)
+# 校验分支
+if core_param_branch is None:
+    print("分支错误，结束")
+    exit(1)
+if api_param_branch is None:
+    print("分支错误，结束")
+    exit(1)
+if api_param_folder is None or api_param_folder == '' or api_param_folder == ' ' or api_param_folder == 'none' or api_param_folder == 'None':
+    api_param_folder = None
+# 如果dev44及以上环境，只能使用模式0：
+if cd_env.startswith('dev') and int(cd_env[3:]) >= 44 and build_mode != '0':
+    print("dev43及以上环境只能使用模式0，结束")
+    exit(1)
+
+# 保存到本地环境
+cd_env_json['cd_env'] = cd_env
+cd_env_json['core_param_branch'] = core_param_branch
+cd_env_json['api_param_branch'] = api_param_branch
+cd_env_json['api_param_folder'] = api_param_folder
+cd_env_json['build_mode'] = build_mode
+json.dump(cd_env_json, open(current_dir + '/last_cd_env.json', 'w', encoding='utf-8'), ensure_ascii=False)
+
+# exit(0)
+
+# 根据环境输入，设置前缀
+env_prefix = 'dev' if cd_env.startswith('dev') else 'test'
+
+# 读取上一次构建的环境
+with open(current_dir + '/env_param.json', 'r', encoding='utf-8') as f:
+    env_param = json.load(f)
+
+jenkins_user_id = env_param['jenkins_user_id'][env_prefix]
+jenkins_api_token = env_param['jenkins_api_token'][env_prefix]
+core_job = env_param['core_job'][env_prefix]
+api_job = env_param['api_job'][env_prefix]
+if api_param_folder is not None:
+    core_job = api_param_folder + '/' + env_param['core_job_custom'][env_prefix]
+    api_job = api_param_folder + '/' + env_param['api_job_custom'][env_prefix]
+
+# portainer配置（如果cd_env > dev15，使用另一套配置）
+if cd_env.startswith('dev') and int(cd_env[3:]) > 15:
+    portainer_user_name = env_param['portainer_user_name']['dev16']
+    portainer_user_pwd = env_param['portainer_user_pwd']['dev16']
+    portainer_api_url = env_param['portainer_api_url']['dev16']
+    portainer_endpoints = env_param['portainer_endpoints']['dev16']
+    portainer_server_suffix = env_param['portainer_server_suffix']['dev16']
+else:
+    portainer_api_url = env_param['portainer_api_url'][env_prefix]
+    portainer_user_name = env_param['portainer_user_name'][env_prefix]
+    portainer_user_pwd = env_param['portainer_user_pwd'][env_prefix]
+    portainer_endpoints = env_param['portainer_endpoints'][env_prefix]
+    portainer_server_suffix = env_param['portainer_server_suffix'][env_prefix]
+
+# ~~~~~~~~~~~~~~~~~ 开始打包 ~~~~~~~~~~~~~~~~~~~~~~~~
+
+print('\n~~~~~~~~~~~~~~\n')
+print('开始打包')
+print("链接jenkins：" + jenkins_server_url)
+
+# 实例化jenkins对象，连接远程的jenkins master server
+j_server = jenkins.Jenkins(url=jenkins_server_url, username=jenkins_user_id, password=jenkins_api_token)
+print("jenkins信息：" + j_server.get_whoami()['fullName'])
+
+# 通过参数构建core
+if int(build_mode) < 2:
+    print('开始构建core：' + core_job + ' ' + time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
+    rs = do_job(j_server, core_job, core_param_branch, cd_env, core_timeout)
+    if rs is False:
+        print('构建core失败，结束')
+        exit(1)
+    time.sleep(10)
+
+if int(build_mode) < 3:
+    print('开始构建api：' + api_job + ' ' + time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
+    rs = do_job(j_server, api_job, api_param_branch, cd_env, api_timeout)
+    # 如果构建api失败，再次构建
+    # if rs is False:
+    #     print('第一次构建api失败，再次构建')
+    #     rs = do_job_1(j_server, api_job, api_param_branch, cd_env, api_timeout)
+    if rs is False:
+        print('构建api失败，结束')
+        exit(1)
+    time.sleep(2)
+
+print('结束打包' + ' ' + time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
+
+# ~~~~~~~~~~~~~~~~~ 开始更新 ~~~~~~~~~~~~~~~~~~~~~~~~
+
+# 开始更新portainer
+if int(build_mode) == 0:
+    print('\n~~~~~~~ 请自行更新portainer ~~~~~~~\n')
+else:
+    print('\n~~~~~~~~~~~~~~\n')
+    print('开始更新portainer：' + portainer_api_url + ' ' + time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
+    # portainer配置（如果cd_env > dev15，使用update）
+    if cd_env.startswith('dev') and int(cd_env[3:]) > 15:
+        # 通过update更新
+        update_portainer()
+    else:
+        # 触发webhook
+        trigger_webhook()
+
+
+exit(0)

package/.claude/skills/jenkins-deploy/assets/last_cd_env.template.json

@@ -0,0 +1,7 @@
+{
+  "build_mode": "1",
+  "cd_env": "dev1",
+  "core_param_branch": "master",
+  "api_param_branch": "master",
+  "api_param_folder": null
+}

package/.codex/skills/jenkins-deploy/SKILL.md

@@ -0,0 +1,207 @@
+---
+name: jenkins-deploy
+description: |
+  Jenkins + Portainer 自动打包部署技能。通过 Python 脚本调用 Jenkins API 构建项目，并触发 Portainer Webhook/Update 完成容器更新。
+
+  触发场景：
+  - 需要将代码打包部署到 dev/test 环境
+  - 需要触发 Jenkins 构建 core 或 api 项目
+  - 需要更新 Portainer 容器服务
+  - 需要查看或修改构建配置（分支、环境、模式）
+  - 定制项目的打包部署
+
+  触发词：打包、部署、Jenkins、构建、Portainer、发布到dev、发布到test、更新环境、自动部署
+---
+
+# Jenkins + Portainer 自动打包部署
+
+## 概述
+
+项目使用 `jenkins/` 目录下的 Python 脚本实现自动化构建部署，流程：
+
+```
+Jenkins 构建 core → Jenkins 构建 api → Portainer 更新容器
+```
+
+## 文件位置
+
+| 文件 | 作用 |
+|------|------|
+| `jenkins/jk_build.py` | 主构建脚本 |
+| `jenkins/env_param.json` | 环境配置（Jenkins/Portainer 连接参数） |
+| `jenkins/last_cd_env.json` | 上次构建参数（自动保存） |
+
+## 构建模式
+
+| 模式 | 说明 | 执行步骤 |
+|------|------|---------|
+| `0` | 只构建 | 构建 core + api，不更新 Portainer |
+| `1` | 全构建+更新 | 构建 core + api → 触发 Portainer 更新 |
+| `2` | 构建 api+更新 | 跳过 core，构建 api → 触发 Portainer 更新 |
+| `3` | 只更新 | 不构建，直接触发 Portainer 更新 |
+
+## 环境支持
+
+| 环境 | 前缀 | Jenkins Job | Portainer |
+|------|------|-------------|-----------|
+| 开发环境 | `dev` + 编号 | `dev-tengyun-core` / `dev-tengyun-yunshitang-api` | devops-dev.xnzn.net |
+| 测试环境 | `test` + 编号 | `test-tengyun-core` / `test-tengyun-yunshitang-api` | devops-test.xnzn.net |
+| dev16+ | `dev16` ~ `dev43` | 同 dev | xnzn-dev.xnzn.net（使用 forceupdateservice） |
+| dev44+ | `dev44` 及以上 | 只支持模式 0 | 需手动更新 |
+
+## 定制项目支持
+
+当指定 `api_param_folder`（定制工程文件夹名）时，Jenkins Job 路径变为：
+
+```
+{folder_name}/dev-后端-core    # 替代 dev-tengyun-core
+{folder_name}/dev-后端-api     # 替代 dev-tengyun-yunshitang-api
+```
+
+## 使用方式
+
+### 直接运行脚本
+
+```bash
+cd jenkins && python jk_build.py
+```
+
+脚本会交互式询问：
+1. **模式**（0/1/2/3）
+2. **环境**（dev1, dev2, test1 等）
+3. **core 分支**（如 release_5.56.0）
+4. **api 分支**（如 master）
+5. **定制工程文件夹**（可选，空格或 None 跳过）
+
+### 通过 Claude 辅助部署
+
+当用户说"打包到 devX"时：
+
+1. **读取** `jenkins/last_cd_env.json` 获取上次构建参数
+2. **确认参数**：环境、分支、模式、是否定制项目
+3. **修改** `last_cd_env.json` 写入新参数
+4. **执行** `cd jenkins && python jk_build.py`（脚本读取预设值，用户直接回车即可）
+
+## 配置文件说明
+
+### last_cd_env.json（构建参数）
+
+```json
+{
+  "build_mode": "0",
+  "cd_env": "dev63",
+  "core_param_branch": "release_5.56.0",
+  "api_param_branch": "master",
+  "api_param_folder": null
+}
+```
+
+| 字段 | 说明 |
+|------|------|
+| `build_mode` | 构建模式（0/1/2/3） |
+| `cd_env` | 目标环境（如 dev1, test2） |
+| `core_param_branch` | core 仓库分支 |
+| `api_param_branch` | api 仓库分支 |
+| `api_param_folder` | 定制项目文件夹（null 表示标准项目） |
+
+### env_param.json（环境连接配置）
+
+包含 Jenkins 和 Portainer 的连接参数（用户名、API Token、服务地址等），按 dev/test 环境分组。
+
+> **注意**：此文件包含敏感凭证，不要将内容输出到对话中。
+
+## 构建流程详解
+
+```
+1. 连接 Jenkins（ci.xnzn.net）
+2. 构建 core（参数：BRANCH + VERSION=环境名）
+   └─ 轮询构建进度，超时 10 分钟
+3. 构建 api（参数同上）
+   └─ 轮询构建进度，超时 5 分钟
+4. 更新 Portainer：
+   ├─ dev1~15：Webhook 触发
+   │   └─ 获取 JWT → 查 Service ID → 获取/创建 Webhook → POST 触发
+   └─ dev16+：Force Update
+       └─ 获取 JWT → 查 Service ID → PUT forceupdateservice
+```
+
+## 常见操作
+
+### 只改了 api 代码，快速部署
+
+```bash
+# 修改 last_cd_env.json 的 build_mode 为 "2"，然后运行
+cd jenkins && python jk_build.py
+```
+
+### 只需要更新容器（已在 Jenkins 手动构建完）
+
+```bash
+# build_mode 设为 "3"
+cd jenkins && python jk_build.py
+```
+
+### 部署定制项目
+
+```json
+// last_cd_env.json
+{
+  "api_param_folder": "leniu-tengyun-wuhanxieheyiyuan"
+}
+```
+
+## 首次初始化（团队成员）
+
+当用户说"初始化部署环境"或检测到 `jenkins/` 目录不存在时，执行以下步骤：
+
+### 自动初始化流程
+
+```bash
+# 1. 创建 jenkins 目录
+mkdir -p jenkins
+
+# 2. 从技能模板复制文件（SKILL_DIR 为技能目录路径）
+cp .claude/skills/jenkins-deploy/assets/jk_build.py jenkins/jk_build.py
+cp .claude/skills/jenkins-deploy/assets/last_cd_env.template.json jenkins/last_cd_env.json
+
+# 3. 环境配置需要用户提供（含敏感凭证）
+cp .claude/skills/jenkins-deploy/assets/env_param.template.json jenkins/env_param.json
+
+# 4. 安装依赖
+pip install python-jenkins requests
+```
+
+### 配置凭证
+
+初始化后，`jenkins/env_param.json` 中的占位符需要替换为真实值：
+
+| 占位符 | 说明 | 获取方式 |
+|--------|------|---------|
+| `__JENKINS_DEV_USER__` | Jenkins dev 账号 | 向团队负责人获取 |
+| `__JENKINS_DEV_TOKEN__` | Jenkins dev API Token | Jenkins → 用户 → 设置 → API Token |
+| `__JENKINS_TEST_USER__` | Jenkins test 账号 | 同上 |
+| `__JENKINS_TEST_TOKEN__` | Jenkins test API Token | 同上 |
+| `__PORTAINER_*_USER__` | Portainer 用户名 | 向团队负责人获取 |
+| `__PORTAINER_*_PWD__` | Portainer 密码 | 向团队负责人获取 |
+
+**快捷方式**：如果团队已有成员配置好，可直接拷贝对方的 `env_param.json` 文件。
+
+### AI 初始化行为
+
+当技能被触发但 `jenkins/` 不存在时：
+1. 提示用户"检测到尚未初始化部署环境"
+2. 询问是否执行初始化
+3. 执行上述复制步骤
+4. 提示用户填写凭证（或拷贝已有配置）
+
+## 依赖
+
+```bash
+pip install python-jenkins requests
+```
+
+## 注意
+
+- 本技能用于 dev/test 环境部署，**不涉及生产环境**
+- 如果是 Git 提交/分支管理，请使用 `git-workflow` 技能
+- 如果是代码构建错误排查，请使用 `bug-detective` 技能

package/.cursor/hooks/cursor-skill-eval.js

@@ -417,6 +417,10 @@ const skillMap = [
   {
     name: 'skill-creator',
     keywords: ['创建技能', '技能模板', '技能脚手架', 'skill scaffold', '新建skill']
+  },
+  {
+    name: 'jenkins-deploy',
+    keywords: ['打包', '部署', 'Jenkins', '构建', 'Portainer', '发布到dev', '发布到test', '更新环境', '自动部署']
   }
 ];
 

package/.cursor/rules/skill-activation.mdc

@@ -87,6 +87,7 @@ alwaysApply: true
 | 多租户/租户隔离/TenantEntity/tenantId/SaaS | `.cursor/skills/tenant-management/SKILL.md` |
 | Element UI/前端组件/el-table/el-form/管理页面 | `.cursor/skills/ui-pc/SKILL.md` |
 | Vuex/store/mapState/mapActions/状态管理 | `.cursor/skills/store-pc/SKILL.md` |
+| 打包/部署/Jenkins/构建/Portainer/发布到dev/发布到test/自动部署 | `.cursor/skills/jenkins-deploy/SKILL.md` |
 
 ### 执行规则
 

package/.cursor/skills/jenkins-deploy/SKILL.md

@@ -0,0 +1,207 @@
+---
+name: jenkins-deploy
+description: |
+  Jenkins + Portainer 自动打包部署技能。通过 Python 脚本调用 Jenkins API 构建项目，并触发 Portainer Webhook/Update 完成容器更新。
+
+  触发场景：
+  - 需要将代码打包部署到 dev/test 环境
+  - 需要触发 Jenkins 构建 core 或 api 项目
+  - 需要更新 Portainer 容器服务
+  - 需要查看或修改构建配置（分支、环境、模式）
+  - 定制项目的打包部署
+
+  触发词：打包、部署、Jenkins、构建、Portainer、发布到dev、发布到test、更新环境、自动部署
+---
+
+# Jenkins + Portainer 自动打包部署
+
+## 概述
+
+项目使用 `jenkins/` 目录下的 Python 脚本实现自动化构建部署，流程：
+
+```
+Jenkins 构建 core → Jenkins 构建 api → Portainer 更新容器
+```
+
+## 文件位置
+
+| 文件 | 作用 |
+|------|------|
+| `jenkins/jk_build.py` | 主构建脚本 |
+| `jenkins/env_param.json` | 环境配置（Jenkins/Portainer 连接参数） |
+| `jenkins/last_cd_env.json` | 上次构建参数（自动保存） |
+
+## 构建模式
+
+| 模式 | 说明 | 执行步骤 |
+|------|------|---------|
+| `0` | 只构建 | 构建 core + api，不更新 Portainer |
+| `1` | 全构建+更新 | 构建 core + api → 触发 Portainer 更新 |
+| `2` | 构建 api+更新 | 跳过 core，构建 api → 触发 Portainer 更新 |
+| `3` | 只更新 | 不构建，直接触发 Portainer 更新 |
+
+## 环境支持
+
+| 环境 | 前缀 | Jenkins Job | Portainer |
+|------|------|-------------|-----------|
+| 开发环境 | `dev` + 编号 | `dev-tengyun-core` / `dev-tengyun-yunshitang-api` | devops-dev.xnzn.net |
+| 测试环境 | `test` + 编号 | `test-tengyun-core` / `test-tengyun-yunshitang-api` | devops-test.xnzn.net |
+| dev16+ | `dev16` ~ `dev43` | 同 dev | xnzn-dev.xnzn.net（使用 forceupdateservice） |
+| dev44+ | `dev44` 及以上 | 只支持模式 0 | 需手动更新 |
+
+## 定制项目支持
+
+当指定 `api_param_folder`（定制工程文件夹名）时，Jenkins Job 路径变为：
+
+```
+{folder_name}/dev-后端-core    # 替代 dev-tengyun-core
+{folder_name}/dev-后端-api     # 替代 dev-tengyun-yunshitang-api
+```
+
+## 使用方式
+
+### 直接运行脚本
+
+```bash
+cd jenkins && python jk_build.py
+```
+
+脚本会交互式询问：
+1. **模式**（0/1/2/3）
+2. **环境**（dev1, dev2, test1 等）
+3. **core 分支**（如 release_5.56.0）
+4. **api 分支**（如 master）
+5. **定制工程文件夹**（可选，空格或 None 跳过）
+
+### 通过 Claude 辅助部署
+
+当用户说"打包到 devX"时：
+
+1. **读取** `jenkins/last_cd_env.json` 获取上次构建参数
+2. **确认参数**：环境、分支、模式、是否定制项目
+3. **修改** `last_cd_env.json` 写入新参数
+4. **执行** `cd jenkins && python jk_build.py`（脚本读取预设值，用户直接回车即可）
+
+## 配置文件说明
+
+### last_cd_env.json（构建参数）
+
+```json
+{
+  "build_mode": "0",
+  "cd_env": "dev63",
+  "core_param_branch": "release_5.56.0",
+  "api_param_branch": "master",
+  "api_param_folder": null
+}
+```
+
+| 字段 | 说明 |
+|------|------|
+| `build_mode` | 构建模式（0/1/2/3） |
+| `cd_env` | 目标环境（如 dev1, test2） |
+| `core_param_branch` | core 仓库分支 |
+| `api_param_branch` | api 仓库分支 |
+| `api_param_folder` | 定制项目文件夹（null 表示标准项目） |
+
+### env_param.json（环境连接配置）
+
+包含 Jenkins 和 Portainer 的连接参数（用户名、API Token、服务地址等），按 dev/test 环境分组。
+
+> **注意**：此文件包含敏感凭证，不要将内容输出到对话中。
+
+## 构建流程详解
+
+```
+1. 连接 Jenkins（ci.xnzn.net）
+2. 构建 core（参数：BRANCH + VERSION=环境名）
+   └─ 轮询构建进度，超时 10 分钟
+3. 构建 api（参数同上）
+   └─ 轮询构建进度，超时 5 分钟
+4. 更新 Portainer：
+   ├─ dev1~15：Webhook 触发
+   │   └─ 获取 JWT → 查 Service ID → 获取/创建 Webhook → POST 触发
+   └─ dev16+：Force Update
+       └─ 获取 JWT → 查 Service ID → PUT forceupdateservice
+```
+
+## 常见操作
+
+### 只改了 api 代码，快速部署
+
+```bash
+# 修改 last_cd_env.json 的 build_mode 为 "2"，然后运行
+cd jenkins && python jk_build.py
+```
+
+### 只需要更新容器（已在 Jenkins 手动构建完）
+
+```bash
+# build_mode 设为 "3"
+cd jenkins && python jk_build.py
+```
+
+### 部署定制项目
+
+```json
+// last_cd_env.json
+{
+  "api_param_folder": "leniu-tengyun-wuhanxieheyiyuan"
+}
+```
+
+## 首次初始化（团队成员）
+
+当用户说"初始化部署环境"或检测到 `jenkins/` 目录不存在时，执行以下步骤：
+
+### 自动初始化流程
+
+```bash
+# 1. 创建 jenkins 目录
+mkdir -p jenkins
+
+# 2. 从技能模板复制文件（SKILL_DIR 为技能目录路径）
+cp .claude/skills/jenkins-deploy/assets/jk_build.py jenkins/jk_build.py
+cp .claude/skills/jenkins-deploy/assets/last_cd_env.template.json jenkins/last_cd_env.json
+
+# 3. 环境配置需要用户提供（含敏感凭证）
+cp .claude/skills/jenkins-deploy/assets/env_param.template.json jenkins/env_param.json
+
+# 4. 安装依赖
+pip install python-jenkins requests
+```
+
+### 配置凭证
+
+初始化后，`jenkins/env_param.json` 中的占位符需要替换为真实值：
+
+| 占位符 | 说明 | 获取方式 |
+|--------|------|---------|
+| `__JENKINS_DEV_USER__` | Jenkins dev 账号 | 向团队负责人获取 |
+| `__JENKINS_DEV_TOKEN__` | Jenkins dev API Token | Jenkins → 用户 → 设置 → API Token |
+| `__JENKINS_TEST_USER__` | Jenkins test 账号 | 同上 |
+| `__JENKINS_TEST_TOKEN__` | Jenkins test API Token | 同上 |
+| `__PORTAINER_*_USER__` | Portainer 用户名 | 向团队负责人获取 |
+| `__PORTAINER_*_PWD__` | Portainer 密码 | 向团队负责人获取 |
+
+**快捷方式**：如果团队已有成员配置好，可直接拷贝对方的 `env_param.json` 文件。
+
+### AI 初始化行为
+
+当技能被触发但 `jenkins/` 不存在时：
+1. 提示用户"检测到尚未初始化部署环境"
+2. 询问是否执行初始化
+3. 执行上述复制步骤
+4. 提示用户填写凭证（或拷贝已有配置）
+
+## 依赖
+
+```bash
+pip install python-jenkins requests
+```
+
+## 注意
+
+- 本技能用于 dev/test 环境部署，**不涉及生产环境**
+- 如果是 Git 提交/分支管理，请使用 `git-workflow` 技能
+- 如果是代码构建错误排查，请使用 `bug-detective` 技能

package/AGENTS.md

@@ -94,6 +94,7 @@
 | `collaborating-with-gemini` | 与 Gemini 协同设计 |
 | `codex-code-review` | 代码审查 |
 | `leniu-marketing-scenario` | 营销规则开发（折扣/满减/限额/限次/补贴/充值赠送/扣款/就餐规则） |
+| `jenkins-deploy` | 打包部署（Jenkins 构建 + Portainer 更新，dev/test 环境） |
 
 ### OpenSpec 规格驱动开发技能（SDD）
 

package/bin/index.js

@@ -586,6 +586,24 @@ function showDoneHint(toolKey) {
     console.log(`  2. 在 Codex 中使用 .codex/skills/ 下的技能`);
     console.log('');
   }
+  showJenkinsHint();
+}
+
+/** 检测 jenkins/ 是否已初始化，提示用户配置部署环境 */
+function showJenkinsHint() {
+  const jenkinsDir = path.join(targetDir, 'jenkins');
+  const envParamFile = path.join(jenkinsDir, 'env_param.json');
+  const skillAssetsDir = path.join(targetDir, '.claude', 'skills', 'jenkins-deploy', 'assets');
+
+  // 技能 assets 存在但 jenkins/ 未初始化
+  if (fs.existsSync(skillAssetsDir) && !fs.existsSync(envParamFile)) {
+    console.log(fmt('yellow', fmt('bold', '📦 Jenkins 部署环境未初始化')));
+    console.log(`  项目包含 ${fmt('bold', 'jenkins-deploy')} 技能，但 jenkins/ 目录尚未配置。`);
+    console.log(`  初始化方式：`);
+    console.log(`    方式 1：在 AI 对话中说 ${fmt('bold', '"初始化部署环境"')}`);
+    console.log(`    方式 2：从团队成员处拷贝 ${fmt('bold', 'jenkins/')} 目录`);
+    console.log('');
+  }
 }
 
 function run(selectedTool) {
@@ -748,6 +766,7 @@ function runUpdate(selectedTool) {
     console.log(`  强制更新保留文件: ${fmt('bold', hintCmd('update --force'))}`);
   }
   console.log('');
+  showJenkinsHint();
 
   if (totalFailed > 0) process.exitCode = 1;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-engineering-init",
-  "version": "1.17.0",
+  "version": "1.17.1",
   "description": "AI 工程化配置初始化工具 — 一键为 Claude Code、OpenAI Codex 等 AI 工具初始化 Skills 和项目规范",
   "keywords": [
     "claude-code",