leniu-dev 2.0.0 → 2.0.1

package/.codex/skills/loki-log-query/SKILL.md

@@ -25,35 +25,9 @@ description: |
 
 ## 多环境配置
 
-### 配置文件查找顺序
+配置文件：`.claude/skills/loki-log-query/environments.json`
 
-```
-1. 本地项目：.claude/loki-config.json（新格式）
-2. 本地项目：.claude/skills/loki-log-query/environments.json（旧格式，兼容）
-3. 全局配置：~/.claude/loki-config.json（或 ~/.cursor/loki-config.json）
-```
-
-本地优先。全局配置用 `npx ai-engineering-init config --type loki --scope global` 创建。
-
-### 配置结构（支持 range 范围匹配）
-
-```json
-{
-  "active": "monitor-dev",
-  "environments": {
-    "monitor-dev": {
-      "name": "Monitor 开发环境",
-      "url": "https://monitor-dev.xnzn.net/grafana",
-      "token": "glsa_xxx",
-      "aliases": ["mdev", "dev"],
-      "range": "dev1~15",
-      "projects": ["dev01","dev02","...","dev15"]
-    }
-  }
-}
-```
-
-### 环境列表（默认）
+### 环境列表
 
 | 环境别名 | 名称 | URL | 快捷词 |
 |----------|------|-----|--------|
@@ -63,34 +37,31 @@ description: |
 | `monitor02-dev` | Monitor02 开发环境 | `https://monitor02-dev.xnzn.net/grafana` | m02, monitor02 |
 | `monitor-tyy-dev` | Monitor 体验园开发环境 | `https://monitor-tyy-dev.xnzn.net/grafana` | tyy, 体验园 |
 
-### 环境匹配规则（含 range）
+### 环境匹配规则
 
-| 用户说法 | 匹配方式 | 结果 |
-|---------|---------|------|
-| "查 test13 的日志" | 精确匹配 key/aliases | `test13` 环境 |
-| "去 dev10 查" | **range 匹配**：dev10 在 monitor-dev 的 projects 中 | `monitor-dev`，`project="dev10"` |
-| "去 monitor-dev 查" | 精确匹配 key | `monitor-dev` 环境 |
-| "切到体验园" | aliases 匹配 | `monitor-tyy-dev` 环境 |
-| 未指定环境 | 使用 `active` 字段 | 默认活跃环境 |
+用户说的话 → 匹配环境：
+- "查 test13 的日志" → `test13`
+- "去 monitor-dev 查" → `monitor-dev`
+- "切到体验园" → `monitor-tyy-dev`
+- "去 m02 查一下" → `monitor02-dev`
+- 未指定环境 → 使用 `active` 字段指定的默认环境
 
-### 读取配置（含全局降级 + range 匹配）
+### 读取配置
 
 ```bash
-# 按优先级查找配置文件
-find_config() {
-  local PROJECT_DIR="${CLAUDE_PROJECT_DIR:-.}"
-  for f in \
-    "${PROJECT_DIR}/.claude/loki-config.json" \
-    "${PROJECT_DIR}/.claude/skills/loki-log-query/environments.json" \
-    "${HOME}/.claude/loki-config.json" \
-    "${HOME}/.cursor/loki-config.json"; do
-    [ -f "$f" ] && echo "$f" && return
-  done
+SKILL_DIR="$CLAUDE_PROJECT_DIR/.claude/skills/loki-log-query"
+ENV_FILE="${SKILL_DIR}/environments.json"
+
+# 读取指定环境（参数: 环境别名）
+read_env() {
+  local ENV_KEY="${1:-$(python3 -c "import json; print(json.load(open('${ENV_FILE}'))['active'])")}"
+  GRAFANA_URL=$(python3 -c "import json; print(json.load(open('${ENV_FILE}'))['environments']['${ENV_KEY}']['url'])")
+  TOKEN=$(python3 -c "import json; print(json.load(open('${ENV_FILE}'))['environments']['${ENV_KEY}']['token'])")
+  API="${GRAFANA_URL}/api/datasources/proxy/uid/loki/loki/api/v1"
+  echo "Environment: ${ENV_KEY} → ${GRAFANA_URL}"
 }
 
-ENV_FILE=$(find_config)
-
-# 通过别名或 range 查找环境 key + project
+# 通过别名查找环境 key
 find_env() {
   python3 -c "
 import json
@@ -98,11 +69,10 @@ data = json.load(open('${ENV_FILE}'))
 alias = '${1}'.lower()
 for key, env in data['environments'].items():
     if alias == key or alias in env.get('aliases', []):
-        print(f'{key}|'); exit()
-for key, env in data['environments'].items():
-    if alias in env.get('projects', []):
-        print(f'{key}|{alias}'); exit()
-print(f'{data[\"active\"]}|')
+        print(key)
+        break
+else:
+    print(data['active'])
 "
 }
 ```

package/.codex/skills/mysql-debug/SKILL.md

@@ -27,28 +27,22 @@ description: |
 
 ---
 
-## 连接信息获取（四级降级，自动查找）
+## 连接信息获取（三级降级，自动查找）
 
 当本技能被激活时，**按以下优先级获取数据库连接信息**：
 
 ### 优先级 1：用户对话中指定（最高优先级）
 
 用户直接给出连接信息，或指定环境名：
-- "连 dev 环境查一下" → 使用配置中 dev 环境
-- "去 dev10 查" → **范围匹配** dev 环境（range: "1~15"）
+- "连 dev 环境查一下" → 使用 `.claude/mysql-config.json` 中 dev 环境的配置
 - 直接给出 host/port/user/password → 直接使用
 
-### 优先级 2：本地项目 `.claude/mysql-config.json`
+### 优先级 2：`.claude/mysql-config.json`（显式配置，可选）
 
-项目目录下的配置文件，优先于全局配置。
+如果文件存在且当前环境的 password 不是占位符 `YOUR_PASSWORD`，使用该配置。
+**此文件为可选**，主要用于连接非本地环境（dev/prod 远程数据库）。
 
-### 优先级 3：全局配置（所有项目共享）
-
-全局配置文件（通过 `npx ai-engineering-init config --scope global` 创建）。
-查找路径：`~/.claude/mysql-config.json` 或 `~/.cursor/mysql-config.json`（取决于使用的工具）。
-**推荐**：公司统一的数据库连接信息放全局，项目特定的覆盖放本地。
-
-### 优先级 4：工程配置文件（零配置，本地开发默认）
+### 优先级 3：工程配置文件（零配置，本地开发默认）
 
 从项目的 `bootstrap-dev.yml` 中自动提取连接信息：
 

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

@@ -58,14 +58,30 @@ python ~/.claude/skills/jenkins-deploy/assets/jk_build.py
 
 脚本交互式询问：模式 → 环境 → core 分支 → api 分支 → 定制工程文件夹
 
+### 命令行模式（推荐，AI 调用）
+
+```bash
+python3 ~/.claude/skills/jenkins-deploy/assets/jk_build.py \
+  --mode 2 --env dev10 --api-branch release_xxx --folder 常州技师学院
+```
+
+| 参数 | 缩写 | 说明 |
+|------|------|------|
+| `--mode` | `-m` | 构建模式（0/1/2/3） |
+| `--env` | `-e` | 目标环境（dev10, test1） |
+| `--core-branch` | | core 分支名 |
+| `--api-branch` | | api 分支名 |
+| `--folder` | `-f` | 定制项目文件夹名 |
+
+未传的参数自动使用 `last_cd_env.json` 中的上次值。
+
 ### 通过 AI 辅助部署
 
-当用户说"打包到 devX"时：
+当用户说"打包到 devX"时，直接用命令行参数调用，不再需要 heredoc 模拟交互：
 
-1. 读取 `jenkins/last_cd_env.json` 获取上次参数
-2. 确认参数：环境、分支、模式
-3. 修改 `jenkins/last_cd_env.json` 写入新参数
-4. 执行 `python ~/.claude/skills/jenkins-deploy/assets/jk_build.py`
+```bash
+python3 ~/.claude/skills/jenkins-deploy/assets/jk_build.py --mode 2 --env dev10 --api-branch master
+```
 
 ## 配置文件
 

package/.cursor/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/.cursor/skills/jenkins-deploy/assets/jk_build.py

@@ -0,0 +1,415 @@
+# 简单调用jenkins api，构建项目并触发webhook
+import argparse
+import html
+import json
+import os
+import sys
+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 = ''
+
+
+# ~~~~~~~~~~~~~~~~~ 配置文件查找 ~~~~~~~~~~~~~~~~~~~~~~~~
+
+def find_config_file(filename, search_paths):
+    """按优先级查找配置文件：本地 > 全局"""
+    for p in search_paths:
+        filepath = os.path.join(p, filename)
+        if os.path.exists(filepath):
+            return filepath
+    return None
+
+
+# 配置文件搜索路径
+project_dir = os.getcwd()
+home_claude_dir = os.path.join(os.path.expanduser('~'), '.claude')
+
+# jenkins-config.json 搜索路径：项目本地 .claude/ > 全局 ~/.claude/
+config_search_paths = [
+    os.path.join(project_dir, '.claude'),
+    home_claude_dir,
+]
+
+# last_cd_env.json 搜索路径：项目本地 jenkins/
+state_dir = os.path.join(project_dir, 'jenkins')
+
+
+# 执行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"
+    }
+    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"
+    }
+
+    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))
+
+# ~~~~~~~~~~~~~~~~~~ 参数解析 ~~~~~~~~~~~~~~~~~~~~~~~
+
+parser = argparse.ArgumentParser(description='Jenkins + Portainer 自动构建部署工具')
+parser.add_argument('--mode', '-m', type=str, help='构建模式: 0-只构建 1-全构建+更新 2-构建api+更新 3-只更新')
+parser.add_argument('--env', '-e', type=str, help='目标环境，如 dev10, test1')
+parser.add_argument('--core-branch', type=str, help='core 分支名')
+parser.add_argument('--api-branch', type=str, help='api 分支名')
+parser.add_argument('--folder', '-f', type=str, help='定制工程文件夹名（如 常州技师学院），不传则为标准项目')
+args = parser.parse_args()
+
+# 判断是否为命令行模式（传了任意参数）
+cli_mode = any([args.mode, args.env, args.core_branch, args.api_branch, args.folder])
+
+# ~~~~~~~~~~~~~~~~~~ 开始输入 ~~~~~~~~~~~~~~~~~~~~~~~
+
+# 打印欢迎信息
+print('\n~~~~~~~~~~~~~~')
+print('正在使用jenkins+portainer构建工具，目前支持dev和test环境的自动化构建+更新')
+print('~~~~~~~~~~~~~~\n')
+
+# 查找环境配置文件（jenkins-config.json）
+config_file = find_config_file('jenkins-config.json', config_search_paths)
+if config_file is None:
+    print('❌ 未找到 jenkins-config.json')
+    print(f'  请将配置文件放到以下任一位置：')
+    for p in config_search_paths:
+        print(f'    - {os.path.join(p, "jenkins-config.json")}')
+    print(f'\n  或运行: npx ai-engineering-init config --type jenkins')
+    exit(1)
+print(f'配置文件: {config_file}')
+
+# 确保构建状态目录存在
+os.makedirs(state_dir, exist_ok=True)
+state_file = os.path.join(state_dir, 'last_cd_env.json')
+
+# 读取上一次构建的环境（如果不存在则使用默认值）
+if os.path.exists(state_file):
+    with open(state_file, 'r', encoding='utf-8') as f:
+        cd_env_json = json.load(f)
+else:
+    cd_env_json = {
+        "build_mode": "1",
+        "cd_env": "dev1",
+        "core_param_branch": "master",
+        "api_param_branch": "master",
+        "api_param_folder": None
+    }
+
+if cli_mode:
+    # 命令行模式：直接使用参数，缺省的用上次的值
+    build_mode = args.mode or cd_env_json['build_mode']
+    cd_env = args.env or cd_env_json['cd_env']
+    core_param_branch = args.core_branch or cd_env_json['core_param_branch']
+    api_param_branch = args.api_branch or cd_env_json['api_param_branch']
+    api_param_folder = args.folder if args.folder is not None else cd_env_json.get('api_param_folder')
+    print(f'命令行模式: mode={build_mode} env={cd_env} core={core_param_branch} api={api_param_branch} folder={api_param_folder}')
+else:
+    # 交互模式：从终端获取用户输入
+    build_mode = input(f"请输入模式 0-只构建 1-全构建+更新 2-构建api+更新 3-只更新（预设{cd_env_json['build_mode']}）：", ) or cd_env_json['build_mode']
+    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_param_branch = input(f"请输入api分支（预设：{cd_env_json['api_param_branch']}）:") or cd_env_json['api_param_branch']
+    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(state_file, 'w', encoding='utf-8'), ensure_ascii=False)
+
+# 根据环境输入，设置前缀
+env_prefix = 'dev' if cd_env.startswith('dev') else 'test'
+
+# 读取环境配置（从全局或本地 jenkins-config.json）
+with open(config_file, '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)
+    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)