1
logger.info("Heartbeat cancel build:$buildId,heartBeatInfo:$heartBeatInfo")

1
KillBuildProcessTree.killProcessTree(
2
    projectId = heartBeatInfo.projectId,
3
    buildId = buildId,
4
    vmSeqId = heartBeatInfo.vmSeqId,
5
    taskIds = cancelTaskIds,
6
    forceFlag = true
7
)

1
if (!cancelTaskIds.isNullOrEmpty()) {
2
    val taskExecutorMap = TaskExecutorCache.getAllPresent(cancelTaskIds)
3
    taskExecutorMap?.forEach { taskId, executor ->
4
        logger.info("Heartbeat taskId[$taskId] executor shutdownNow")
5
        executor.shutdownNow()
6
        TaskExecutorCache.invalidate(taskId)
7
    }
8
}

1
val currentProcessId = if (AgentEnv.getOS() == OSType.WINDOWS) {
2
    getCurrentPID()  // Windows: 通过ManagementFactory获取
3
} else {
4
    getUnixPID()    // Unix/Linux: 通过shell获取父进程ID
5
}

1
val processTree = BkProcessTree.get()
2
val processTreeIterator = processTree.iterator()

1
if (flag) {
2
    osProcess.killRecursively(forceFlag)  // 递归终止子进程
3
    osProcess.kill(forceFlag)             // 终止当前进程
4
    killedProcessIds.add(osProcess.pid)   // 记录已终止的PID
5
}

1
public synchronized EnvVars getEnvironmentVariables() {
2
    if (this.envVars == null) {
3
        this.envVars = new EnvVars();
4

5
        try {
6
            byte[] environ = Linux.this.readFileToByteArray(this.getFile("environ"));
7
            int pos = 0;
8

9
            for (int i = 0; i < environ.length; ++i) {
10
                byte b = environ[i];
11
                if (b == 0) {
12
                    this.envVars.addLine(new String(environ, pos, i - pos));
13
                    pos = i + 1;
14
                }
15
            }
16
        } catch (IOException var5) {
17
            log(var5.getMessage());
18
        }
19

20
    }
21
    return this.envVars;
22
}

1
private void parse() {
2
    try {
3
        this.arguments = new ArrayList<>();
4
        this.envVars = new EnvVars();
5

6
        // 1. 获取系统参数最大长度
7
        IntByReference argmaxRef = new IntByReference(0);
8
        IntByReference size = new IntByReference(BkProcessTree.Darwin.sizeOfInt);
9
        if (GNUCLibrary.LIBC.sysctl(new int[]{1, 8}, 2, argmaxRef.getPointer(),
10
                                     size, Pointer.NULL, defaultSize) != 0) {
11
            throw new IOException("Failed to get kernl.argmax");
12
        }
13

14
        int argmax = argmaxRef.getValue();
15

16
        // 2. 使用 sysctl 获取进程参数和环境变量
17
        StringArrayMemory m = new StringArrayMemory((long)argmax);
18
        size.setValue(argmax);
19

20
        // kern.procargs2 调用获取进程信息
21
        if (GNUCLibrary.LIBC.sysctl(new int[]{1, 49, this.pid}, 3, m, size,
22
                                     Pointer.NULL, defaultSize) != 0) {
23
            throw new IOException("Failed to obtain ken.procargs2");
24
        }
25

26
        // 3. 解析数据...
27
        int argc = m.readInt();  // 读取参数数量
28
        m.readString();  // 跳过可执行文件路径
29
        m.skip0();  // 跳过对齐字节
30

31
        // 读取命令行参数
32
        for (int i = 0; i < argc; ++i) {
33
            this.arguments.add(m.readString());
34
        }
35

36
        // 4. 读取环境变量
37
        while(m.peek() != 0) {
38
            this.envVars.addLine(m.readString());
39
        }
40
    } catch (IOException var10) {
41
        log(var10.getMessage());  // 错误仅记录日志
42
    }
43
}

1
#include <stdio.h>
2
#include <stdlib.h>
3
#include <string.h>
4
#include <sys/sysctl.h>
5
#include <errno.h>
6
#include <unistd.h>
7

8
// 打印美观的分隔线
9
void printSeparator(const char* title) {
10
    printf("\n┌─────────────────────────────────────────────────────────────┐\n");
11
    printf("│ %-57s │\n", title);
12
    printf("└─────────────────────────────────────────────────────────────┘\n");
13
}
14

15
int main(int argc, char *argv[]) {
16
    int pid;
17

18
    // 确定目标PID
19
    if (argc == 2) {
20
        pid = atoi(argv[1]);
21
    } else {
22
        pid = getpid();
23
        printf("ℹ️  未指定PID，默认解析当前进程 (PID = %d)\n", pid);
24
    }
25

26
    printSeparator("开始解析进程参数");
27
    printf("目标进程ID: %d\n", pid);
28

29
    // 1. 获取 argmax (KERN_ARGMAX)
30
    int argmax;
31
    size_t argmax_size = sizeof(argmax);
32
    int mib_argmax[2] = {CTL_KERN, KERN_ARGMAX};
33

34
    if (sysctl(mib_argmax, 2, &argmax, &argmax_size, NULL, 0) == -1) {
35
        perror("❌ 获取 KERN_ARGMAX 失败");
36
        return 1;
37
    }
38

39
    // 2. 获取 KERN_PROCARGS2 原始数据
40
    char *buffer = (char*)malloc(argmax);
41
    if (!buffer) {
42
        perror("❌ 内存分配失败");
43
        return 1;
44
    }
45

46
    int mib_procargs2[3] = {CTL_KERN, KERN_PROCARGS2, pid};
47
    size_t data_size = argmax;
48

49
    if (sysctl(mib_procargs2, 3, buffer, &data_size, NULL, 0) == -1) {
50
        perror("❌ 获取进程数据失败");
51
        if (errno == EPERM) {
52
            printf("💡 提示：尝试使用 'sudo' 获取更高权限\n");
53
        } else if (errno == ESRCH) {
54
            printf("💡 提示：进程 %d 不存在\n", pid);
55
        }
56
        free(buffer);
57
        return 1;
58
    }
59

60
    printf("✅ 数据获取成功\n");
61
    printf("   原始数据大小: %zu 字节\n", data_size);
62

63
    // 3. 解析数据
64
    int offset = 0;
65

66
    // 3.1 解析 argc (参数个数)
67
    int argc_val = *(int*)(buffer + offset);
68
    offset += sizeof(int);
69

70
    printSeparator("基本信息");
71
    printf("• 参数个数 (argc): %d\n", argc_val);
72

73
    // 3.2 获取可执行文件路径 (argv[0] 之前)
74
    printf("• 可执行文件路径: ");
75
    while (offset < data_size && buffer[offset] != '\0') {
76
        putchar(buffer[offset]);
77
        offset++;
78
    }
79

80
    // 检查并跳过路径终止符
81
    if (offset < data_size && buffer[offset] == '\0') {
82
        offset++;
83
    } else {
84
        printf("\n⚠️  警告：路径未正常终止，解析可能出错\n");
85
    }
86
    printf("\n");
87

88
    // 3.3 关键修复：更灵活地跳过填充字节
89
    // 不再严格假设填充全为\0或必须4字节对齐
90
    int before_args = offset;
91
    while (offset < data_size && buffer[offset] == '\0') {
92
        offset++;
93
    }
94
    if (offset > before_args) {
95
        printf("• 跳过 %d 个填充空字节\n", offset - before_args);
96
    }
97

98
    // 3.4 解析命令行参数 (增强容错)
99
    if (argc_val > 0) {
100
        printSeparator("命令行参数");
101
        for (int i = 0; i < argc_val && offset < data_size; i++) {
102
            printf("  %2d. ", i);
103

104
            int arg_start = offset;
105
            int arg_len = 0;
106

107
            // 尝试读取一个参数：尽可能打印可打印字符，直到遇到\0或数据末尾
108
            while (offset < data_size && buffer[offset] != '\0') {
109
                // 只打印可打印ASCII字符，其他显示为?
110
                unsigned char c = buffer[offset];
111
                if (c >= 32 && c <= 126) {
112
                    putchar(c);
113
                } else {
114
                    printf("[0x%02x]", c); // 非打印字符显示为十六进制
115
                }
116
                offset++;
117
                arg_len++;
118
            }
119

120
            if (arg_len == 0) {
121
                printf("(空字符串)");
122
            }
123

124
            // 如果当前位置是\0，则跳过它，准备下一个参数
125
            if (offset < data_size && buffer[offset] == '\0') {
126
                offset++;
127
            }
128

129
            printf("\n");
130
        }
131
    } else {
132
        printSeparator("命令行参数");
133
        printf("  (无命令行参数)\n");
134
    }
135

136
    // 3.5 解析环境变量
137
    printSeparator("环境变量");
138
    int env_count = 0;
139

140
    while (offset < data_size && buffer[offset] != '\0') {
141
        printf("  %3d. ", ++env_count);
142

143
        // 打印变量名（到'='为止）
144
        while (offset < data_size && buffer[offset] != '\0' && buffer[offset] != '=') {
145
            putchar(buffer[offset]);
146
            offset++;
147
        }
148

149
        // 打印'='和变量值
150
        if (offset < data_size && buffer[offset] == '=') {
151
            putchar('=');
152
            offset++;
153

154
            while (offset < data_size && buffer[offset] != '\0') {
155
                putchar(buffer[offset]);
156
                offset++;
157
            }
158
        } else {
159
            // 没有'='的环境变量
160
            while (offset < data_size && buffer[offset] != '\0') {
161
                putchar(buffer[offset]);
162
                offset++;
163
            }
164
        }
165

166
        // 跳过当前环境变量的终止符
167
        if (offset < data_size && buffer[offset] == '\0') {
168
            offset++;
169
        }
170

171
        printf("\n");
172
    }
173

174
    if (env_count == 0) {
175
        printf("  (无环境变量或数据解析完毕)\n");
176
    }
177

178
    printSeparator("解析完成");
179
    printf("✅ 成功解析 %d 个参数和 %d 个环境变量\n", argc_val, env_count);
180
    printf("📊 总计处理数据: %zu 字节，最终偏移: 0x%x\n", data_size, offset);
181

182
    free(buffer);
183
    return 0;
184
}

1
gcc -o show_procargs show_procargs.c

1
./show_procargs pid

1
┌─────────────────────────────────────────────────────────────┐
2
│ 开始解析进程参数                                  │
3
└─────────────────────────────────────────────────────────────┘
4
目标进程ID: 5080
5
✅ 数据获取成功
6
   原始数据大小: 100 字节
7

8
┌─────────────────────────────────────────────────────────────┐
9
│ 基本信息                                              │
10
└─────────────────────────────────────────────────────────────┘
11
• 参数个数 (argc): 2
12
• 可执行文件路径: /bin/bash
13
• 跳过 6 个填充空字节
14

15
┌─────────────────────────────────────────────────────────────┐
16
│ 命令行参数                                           │
17
└─────────────────────────────────────────────────────────────┘
18
   0. /bin/bash
19
   1. /Users/m200002359/bk-ci/build_tmp/devops_script4772461533909296104.sh
20

21
┌─────────────────────────────────────────────────────────────┐
22
│ 环境变量                                              │
23
└─────────────────────────────────────────────────────────────┘
24
  (无环境变量或数据解析完毕)
25

26
┌─────────────────────────────────────────────────────────────┐
27
│ 解析完成                                              │
28
└─────────────────────────────────────────────────────────────┘
29
✅ 成功解析 2 个参数和 0 个环境变量
30
📊 总计处理数据: 100 字节，最终偏移: 0x64

1
=== 蓝盾信号测试脚本 ===
2
当前PID: 5080
3
[17:35:43] 循环第 1 次执行
4
执行测试命令...
5
[17:35:48] 循环第 2 次执行
6
执行测试命令...
7
[17:35:53] 循环第 3 次执行
8
执行测试命令...
9
[17:35:58] 循环第 4 次执行
10
执行测试命令...
11
[17:36:03] 循环第 5 次执行
12
执行测试命令...
13
[17:36:08] 循环第 6 次执行
14
执行测试命令...
15
Cancelled by huari
16
[17:36:13] 循环第 7 次执行
17
执行测试命令...
18

19
Fail to run the plugin because exit code not equal 0

1
┌─────────────────────────────────────────────────────────────┐
2
│ 开始解析进程参数                                  │
3
└─────────────────────────────────────────────────────────────┘
4
目标进程ID: 28855
5
✅ 数据获取成功
6
   原始数据大小: 96 字节
7

8
┌─────────────────────────────────────────────────────────────┐
9
│ 基本信息                                              │
10
└─────────────────────────────────────────────────────────────┘
11
• 参数个数 (argc): 2
12
• 可执行文件路径: /bin/bash
13
• 跳过 6 个填充空字节
14

15
┌─────────────────────────────────────────────────────────────┐
16
│ 命令行参数                                           │
17
└─────────────────────────────────────────────────────────────┘
18
   0. /bin/bash
19
   1. /Users/king/bk-agent/build_tmp/devops_script942180256175598069.sh
20

21
┌─────────────────────────────────────────────────────────────┐
22
│ 环境变量                                              │
23
└─────────────────────────────────────────────────────────────┘
24
  (无环境变量或数据解析完毕)
25

26
┌─────────────────────────────────────────────────────────────┐
27
│ 解析完成                                              │
28
└─────────────────────────────────────────────────────────────┘
29
✅ 成功解析 2 个参数和 0 个环境变量
30
📊 总计处理数据: 96 字节，最终偏移: 0x60

1
=== 蓝盾信号测试脚本 ===
2
当前PID: 28855
3
[19:09:37] 循环第 1 次执行
4
执行测试命令...
5
[19:09:42] 循环第 2 次执行
6
执行测试命令...
7
[19:09:47] 循环第 3 次执行
8
执行测试命令...
9
[19:09:52] 循环第 4 次执行
10
执行测试命令...
11
[19:09:57] 循环第 5 次执行
12
执行测试命令...
13
[19:10:02] 循环第 6 次执行
14
执行测试命令...
15
[19:10:07] 循环第 7 次执行
16
执行测试命令...
17
[19:10:12] 循环第 8 次执行
18
执行测试命令...
19
[19:10:17] 循环第 9 次执行
20
执行测试命令...
21
[19:10:22] 循环第 10 次执行
22
执行测试命令...
23
[19:10:27] 循环第 11 次执行
24
执行测试命令...
25
[19:10:32] 循环第 12 次执行
26
执行测试命令...
27
[19:10:37] 循环第 13 次执行
28
执行测试命令...
29
[19:10:42] 循环第 14 次执行
30
执行测试命令...
31
[19:10:47] 循环第 15 次执行
32
执行测试命令...
33
Cancelled by huari
34
[19:10:52] 循环第 16 次执行
35
执行测试命令...
36
[19:10:57] 循环第 17 次执行
37
执行测试命令...
38
[19:11:02] 循环第 18 次执行
39
执行测试命令...
40
[19:11:07] 循环第 19 次执行
41
执行测试命令...
42
[19:11:12] 循环第 20 次执行
43
执行测试命令...
44
[19:11:18] 循环第 21 次执行
45
执行测试命令...
46
[19:11:23] 循环第 22 次执行
47
执行测试命令...
48
[19:11:28] 循环第 23 次执行
49
执行测试命令...
50
[19:11:33] 循环第 24 次执行
51
执行测试命令...
52
2分钟超时，正常结束

1
import java.lang.reflect.Method;
2
import java.util.Map;
3
import java.util.Iterator;
4

5
public class DirectTest {
6

7
    // Java 8兼容的字符串重复方法（替代String.repeat()）
8
    private static String repeatString(String str, int count) {
9
        StringBuilder sb = new StringBuilder();
10
        for (int i = 0; i < count; i++) {
11
            sb.append(str);
12
        }
13
        return sb.toString();
14
    }
15

16
    public static void main(String[] args) throws Exception {
17
        if (args.length != 1) {
18
            System.out.println("==================================================");
19
            System.out.println("蓝盾Agent进程环境变量读取测试 (Java 8兼容版)");
20
            System.out.println("==================================================");
21
            System.out.println("功能：直接调用Agent内置的BkProcessTree类，触发 kern.procargs2 系统调用。");
22
            System.out.println("用法：java DirectTest <要检查的PID>");
23
            System.out.println("示例：");
24
            System.out.println("  java DirectTest $$      # 检查当前Shell进程");
25
            System.out.println("  java DirectTest 1       # 检查系统launchd进程(需要sudo)");
26
            System.out.println("  java DirectTest [PID]   # 检查任意进程");
27
            System.out.println("==================================================");
28
            return;
29
        }
30

31
        String targetPidStr = args[0];
32
        System.out.println("🔍 开始检查进程 PID: " + targetPidStr);
33
        System.out.println("   使用Agent内置类路径和Java " + System.getProperty("java.version"));
34
        System.out.println();
35

36
        try {
37
            // 1. 获取 BkProcessTree 单例实例 (调用公开的静态方法)
38
            Class<?> bkProcessTreeClass = Class.forName("com.tencent.process.BkProcessTree");
39
            Method getMethod = bkProcessTreeClass.getMethod("get");
40
            Object processTreeInstance = getMethod.invoke(null);
41
            System.out.println("✅ 步骤1: 获取 BkProcessTree 实例成功");
42

43
            // 2. 获取进程树迭代器
44
            Method iteratorMethod = processTreeInstance.getClass().getMethod("iterator");
45
            Iterator<?> iterator = (Iterator<?>) iteratorMethod.invoke(processTreeInstance);
46
            System.out.println("✅ 步骤2: 获取进程树迭代器成功");
47

48
            // 3. 遍历查找目标PID
49
            boolean found = false;
50
            int searchCount = 0;
51

52
            while (iterator.hasNext()) {
53
                Object osProcess = iterator.next();
54
                searchCount++;
55

56
                // 获取当前进程的PID
57
                Method getPidMethod = osProcess.getClass().getMethod("getPid");
58
                int pid = (int) getPidMethod.invoke(osProcess);
59

60
                if (String.valueOf(pid).equals(targetPidStr)) {
61
                    found = true;
62
                    System.out.println("\n🎯 找到目标进程!");
63
                    System.out.println("   进程PID: " + pid);
64
                    System.out.println("   已扫描进程数: " + searchCount);
65
                    System.out.println("\n⚠️  即将触发 kern.procargs2 系统调用...");
66

67
                    // 4. 关键步骤：获取环境变量 (这里会调用 kern.procargs2)
68
                    try {
69
                        Method getEnvMethod = osProcess.getClass().getMethod("getEnvironmentVariables");
70
                        // 修复：设置方法为可访问，绕过Java访问控制
71
                        getEnvMethod.setAccessible(true);
72

73
                        System.out.println("   ⏳ 正在调用 getEnvironmentVariables()...");
74
                        long startTime = System.currentTimeMillis();
75
                        Object envVars = getEnvMethod.invoke(osProcess);
76
                        long endTime = System.currentTimeMillis();
77

78
                        System.out.println("   ⏱️  系统调用耗时: " + (endTime - startTime) + "ms");
79

80
                        // 5. 处理返回的环境变量
81
                        if (envVars == null) {
82
                            System.out.println("\n❌ 结果：getEnvironmentVariables() 返回了 null");
83
                            System.out.println("   这意味着 kern.procargs2 可能返回了空数据。");
84
                        } else if (envVars instanceof Map) {
85
                            Map<?, ?> envMap = (Map<?, ?>) envVars;
86
                            System.out.println("\n✅ 结果：成功获取到环境变量!");
87
                            System.out.println("   环境变量总数: " + envMap.size() + " 个");
88

89
                            // 重点显示蓝盾关心的变量
90
                            System.out.println("\n📋 蓝盾关键环境变量检查:");
91
                            System.out.println("   " + repeatString("-", 50));
92

93
                            String[] blueKingKeys = {
94
                                "PROJECT_ID", "BUILD_ID", "VM_SEQ_ID",
95
                                "PIPELINE_ELEMENT_ID", "DEVOPS_DONT_KILL_PROCESS_TREE"
96
                            };
97

98
                            boolean foundBlueKingVar = false;
99
                            for (String key : blueKingKeys) {
100
                                if (envMap.containsKey(key)) {
101
                                    System.out.printf("   %-30s = %s%n", key, envMap.get(key));
102
                                    foundBlueKingVar = true;
103
                                }
104
                            }
105

106
                            if (!foundBlueKingVar) {
107
                                System.out.println("   ⚠️  未找到蓝盾关键环境变量");
108
                                if (envMap.size() > 0) {
109
                                    System.out.println("   前5个环境变量示例:");
110
                                    int count = 0;
111
                                    for (Object key : envMap.keySet()) {
112
                                        if (count >= 5) break;
113
                                        System.out.printf("   %-30s = %s%n", key, envMap.get(key));
114
                                        count++;
115
                                    }
116
                                }
117
                            }
118
                            System.out.println("   " + repeatString("-", 50));
119

120
                        } else {
121
                            System.out.println("\n⚠️  结果：getEnvironmentVariables() 返回了非Map对象");
122
                            System.out.println("   返回类型: " + envVars.getClass().getName());
123
                            System.out.println("   返回值: " + envVars);
124
                        }
125

126
                    } catch (Exception e) {
127
                        System.out.println("\n❌ 关键错误：获取环境变量时发生异常!");
128
                        System.out.println("   这很可能意味着 kern.procargs2 系统调用失败");
129
                        System.out.println("\n📋 异常详情:");
130
                        System.out.println("   异常类型: " + e.getClass().getName());
131

132
                        // 提取根本原因
133
                        Throwable cause = e;
134
                        while (cause.getCause() != null) {
135
                            cause = cause.getCause();
136
                        }
137

138
                        System.out.println("   根本原因: " + cause.getClass().getName());
139
                        System.out.println("   错误信息: " + cause.getMessage());
140

141
                        // 如果是IOException，很可能是sysctl调用失败
142
                        if (cause instanceof java.io.IOException) {
143
                            System.out.println("\n💡 诊断：这是 kern.procargs2 系统调用失败的直接证据！");
144
                            System.out.println("   在 macOS 上，通常意味着:");
145
                            System.out.println("   1. 进程不存在或已退出");
146
                            System.out.println("   2. 权限不足（某些系统进程需要root权限）");
147
                            System.out.println("   3. macOS版本不兼容（特别是M1/M3芯片的Mac）");
148
                            System.out.println("   4. kern.procargs2 接口已被限制或废弃");
149
                        }
150

151
                        // 打印部分堆栈跟踪（只显示关键部分）
152
                        System.out.println("\n🔍 异常堆栈（关键部分）:");
153
                        StackTraceElement[] stack = cause.getStackTrace();
154
                        for (int i = 0; i < Math.min(stack.length, 5); i++) {
155
                            System.out.println("   at " + stack[i]);
156
                        }
157
                    }
158

159
                    break; // 找到目标进程后停止遍历
160
                }
161
            }
162

163
            if (!found) {
164
                System.out.println("\n⚠️  未在进程树中找到PID为 " + targetPidStr + " 的进程");
165
                System.out.println("   已扫描进程数: " + searchCount);
166
                System.out.println("   可能的原因:");
167
                System.out.println("   1. 进程确实不存在");
168
                System.out.println("   2. 进程是内核线程或特殊进程");
169
                System.out.println("   3. BkProcessTree 的进程列表不完整");
170
            }
171

172
        } catch (Exception e) {
173
            System.out.println("\n❌ 程序初始化失败:");
174
            e.printStackTrace();
175
        }
176

177
        System.out.println("\n==================================================");
178
        System.out.println("测试完成");
179
        System.out.println("==================================================");
180
    }
181
}

1
# 1. 设置 JAVA_HOME，指向agent本地的JDK目录(先进入蓝盾agent的安装目录！！！)
2
export JAVA_HOME=./jdk/Contents/Home
3

4
# 2. 将 JDK 的 bin 目录添加到 PATH 的最前面，确保系统优先使用它
5
export PATH=$JAVA_HOME/bin:$PATH
6

7
# 3. 验证配置是否生效：检查 javac 和 java 的版本
8
javac -version
9
java -version
10

11
# 4. 编译（确保在 bk-agent 目录）
12
javac -cp "./worker-agent.jar" DirectTest.java
13

14
# 5. 运行测试
15
java -cp ".:./worker-agent.jar" DirectTest <PID>

1
🔍 开始检查进程 PID: 7797
2
   使用Agent内置类路径和Java 1.8.0_372
3

4
✅ 步骤1: 获取 BkProcessTree 实例成功
5
✅ 步骤2: 获取进程树迭代器成功
6

7
🎯 找到目标进程!
8
   进程PID: 7797
9
   已扫描进程数: 513
10

11
⚠️  即将触发 kern.procargs2 系统调用...
12
   ⏳ 正在调用 getEnvironmentVariables()...
13
   ⏱️  系统调用耗时: 6ms
14

15
✅ 结果：成功获取到环境变量!
16
   环境变量总数: 0 个
17

18
📋 蓝盾关键环境变量检查:
19
   --------------------------------------------------
20
   ⚠️  未找到蓝盾关键环境变量
21
   --------------------------------------------------
22

23
==================================================
24
测试完成
25
==================================================