postar-pipe-mcp 1.0.1 → 1.0.2

package/dist/server.js

@@ -21015,7 +21015,7 @@ function registerGitLab(manager2) {
     manager2.registerConfig("gitlab", {
       name: "gitlab",
       command: "npx",
-      args: ["-y", "@structured-world/gitlab-mcp"],
+      args: ["-y", "gitlab-core-mcp"],
       env: {
         GITLAB_API_URL: gitlabUrl,
         GITLAB_TOKEN: gitlabToken
@@ -21057,11 +21057,21 @@ function initMCPClients() {
 }
 const GITLAB_PREFIX = "mcp_gitlab_";
 function getRegisteredServers() {
-  const servers = ["gitlab"];
+  const servers = [];
+  if (process.env.GITLAB_TOKEN) {
+    servers.push("gitlab");
+    console.error("[MCP-PIPE][DEBUG] 检测到 GITLAB_TOKEN,添加 gitlab 服务器");
+  } else {
+    console.error("[MCP-PIPE][DEBUG] 未检测到 GITLAB_TOKEN");
+  }
   if (process.env.JENKINS_URL && process.env.JENKINS_USER && process.env.JENKINS_TOKEN) {
     servers.push("jenkins");
+    console.error("[MCP-PIPE][DEBUG] 检测到默认 Jenkins 配置");
+  } else {
+    console.error("[MCP-PIPE][DEBUG] 未检测到默认 Jenkins 配置 (JENKINS_URL/JENKINS_USER/JENKINS_TOKEN)");
   }
   const urlPattern = /^JENKINS_([A-Z0-9_]+)_URL$/;
+  console.error("[MCP-PIPE][DEBUG] 开始检测命名 Jenkins 实例...");
   for (const key of Object.keys(process.env)) {
     const match = key.match(urlPattern);
     if (!match) continue;
@@ -21070,11 +21080,14 @@ function getRegisteredServers() {
     const tokenKey = `JENKINS_${suffix}_TOKEN`;
     const user = process.env[userKey];
     const token = process.env[tokenKey];
+    console.error(`[MCP-PIPE][DEBUG] 检查 ${key} -> suffix=${suffix}, user=${!!user}, token=${!!token}`);
     if (user && token) {
       const instanceName = `jenkins-${suffix.toLowerCase().replace(/_/g, "-")}`;
       servers.push(instanceName);
+      console.error(`[MCP-PIPE][DEBUG] ✅ 添加命名 Jenkins 实例: ${instanceName}`);
     }
   }
+  console.error(`[MCP-PIPE][DEBUG] 最终注册的服务器列表: ${servers.join(", ") || "(空)"}`);
   return servers;
 }
 function getToolPrefix(serverName) {
@@ -21097,41 +21110,45 @@ async function getProxiedTools() {
   const jenkinsServers = servers.filter((s) => s.startsWith("jenkins") && s !== "jenkins");
   const mainJenkins = servers.includes("jenkins") ? "jenkins" : null;
   const otherServers = servers.filter((s) => !s.startsWith("jenkins"));
-  if (mainJenkins) {
-    const prefix = getToolPrefix(mainJenkins);
-    try {
-      const tools = await manager2.listTools(mainJenkins);
-      for (const tool of tools.tools || []) {
-        const proxiedToolName = `${prefix}${tool.name}`;
+  const allJenkinsServers = mainJenkins ? [mainJenkins, ...jenkinsServers] : jenkinsServers;
+  let isFirstJenkins = true;
+  for (const serverName of allJenkinsServers) {
+    const prefix = getToolPrefix(serverName);
+    if (isFirstJenkins) {
+      try {
+        const tools = await manager2.listTools(serverName);
+        for (const tool of tools.tools || []) {
+          const proxiedToolName = `${prefix}${tool.name}`;
+          const proxiedTool = {
+            ...tool,
+            name: proxiedToolName,
+            description: `[${serverName}] ${tool.description || ""}`
+          };
+          allTools.push(proxiedTool);
+          toolSchemaCache.set(proxiedToolName, tool.inputSchema);
+        }
+        console.error(`[MCP-PIPE] 已从 ${serverName} 获取 ${tools.tools?.length || 0} 个工具`);
+        isFirstJenkins = false;
+      } catch (error2) {
+        console.error(`[MCP-PIPE] 无法从 ${serverName} 获取工具列表:`, error2);
+        continue;
+      }
+    } else {
+      const sourcePrefix = mainJenkins ? getToolPrefix(mainJenkins) : getToolPrefix(allJenkinsServers[0]);
+      const jenkinsTools = allTools.filter((t) => t.name.startsWith(sourcePrefix));
+      for (const tool of jenkinsTools) {
+        const originalToolName = tool.name.slice(sourcePrefix.length);
+        const proxiedToolName = `${prefix}${originalToolName}`;
         const proxiedTool = {
           ...tool,
           name: proxiedToolName,
-          description: `[${mainJenkins}] ${tool.description || ""}`
+          description: `[${serverName}] ${tool.description || ""}`
         };
         allTools.push(proxiedTool);
         toolSchemaCache.set(proxiedToolName, tool.inputSchema);
       }
-      console.error(`[MCP-PIPE] 已代理 ${mainJenkins} 的 ${tools.tools?.length || 0} 个工具`);
-    } catch (error2) {
-      console.error(`[MCP-PIPE] 无法获取 ${mainJenkins} 的工具列表:`, error2);
-    }
-  }
-  for (const serverName of jenkinsServers) {
-    const prefix = getToolPrefix(serverName);
-    const sourcePrefix = mainJenkins ? getToolPrefix(mainJenkins) : prefix;
-    const jenkinsTools = allTools.filter((t) => t.name.startsWith(sourcePrefix));
-    for (const tool of jenkinsTools) {
-      const originalToolName = tool.name.slice(sourcePrefix.length);
-      const proxiedToolName = `${prefix}${originalToolName}`;
-      const proxiedTool = {
-        ...tool,
-        name: proxiedToolName,
-        description: `[${serverName}] ${tool.description || ""}`
-      };
-      allTools.push(proxiedTool);
-      toolSchemaCache.set(proxiedToolName, tool.inputSchema);
+      console.error(`[MCP-PIPE] 已为 ${serverName} 生成 ${jenkinsTools.length} 个工具别名`);
     }
-    console.error(`[MCP-PIPE] 已为 ${serverName} 生成 ${jenkinsTools.length} 个工具别名`);
   }
   for (const serverName of otherServers) {
     const prefix = getToolPrefix(serverName);

package/dist/skills/cd/SKILL.md

@@ -117,9 +117,20 @@ version: 1.0.1
    - Jenkins 将使用所有参数的默认值进行构建
 
 2. **若 `config.yaml` 中配置了 `params`**：
-   - 遍历 `jenkins.{ENV}.params` 中的每个参数
-   - **参数值已填写**（非空字符串、非空数组）：直接使用该值
-   - **参数值为空字符串 `""` 或空数组 `[]`**：进入交互流程，让用户选择
+   - 遍历 `jenkins.{ENV}.params` 中的每个参数，根据参数值类型处理：
+   
+   **参数值为数组**（如 `['test', 'pre']`）：
+   - → **使用同一个 Jenkins Job,依次部署多次**
+   - 第 1 次: 传递 `{参数名: 'test'}`
+   - 第 2 次: 传递 `{参数名: 'pre'}`
+   - 示例: `ENV: ['test', 'pre']` → 第1次传 `{ENV: 'test'}`,第2次传 `{ENV: 'pre'}`
+   
+   **参数值为字符串**（如 `'test'`）：
+   - → **部署一次,传递该值**
+   - 示例: `ENV: 'test'` → 传递 `{ENV: 'test'}`
+   
+   **参数值为空**（空字符串 `''`、空数组 `[]`、空对象 `{}`）：
+   - → 进入交互流程，让用户选择
 
 > **交互执行原则、选项获取优先级、占位符替换等详细逻辑**,请参考 `steps.yaml` 中的 `step: 2`
 

package/dist/skills/cd/steps.yaml

@@ -230,15 +230,36 @@ steps:
       - condition: "config.yaml 中未配置 params 或 params 为空对象 {}"
         action: "使用 buildWithParameters 模式触发构建,传递空对象 {}"
         result: "Jenkins 将使用所有参数的默认值进行构建"
+        note: "✅ 未配置任何参数时,直接使用 Jenkins 默认值"
       
       - condition: "config.yaml 中配置了 params"
         action: "遍历 jenkins.{ENV}.params 中的每个参数"
         sub_rules:
-          - condition: "参数值已填写(非空字符串、非空数组)"
-            action: "直接使用该值"
+          - condition: "参数值已填写(非空字符串、非空数组、非空对象)"
+            action: "根据参数值类型处理"
+            value_types:
+              - type: "数组(如 ['test', 'pre'])"
+                action: "使用同一个 Jenkins Job,依次部署多次,每次传递数组中的一个值"
+                example: |
+                  ENV: ['test', 'pre'] → 
+                  第 1 次部署: 调用 Jenkins Job,传递 {ENV: 'test'}
+                  第 2 次部署: 调用 Jenkins Job,传递 {ENV: 'pre'}
+                  
+                  任何参数的数组都这样处理:
+                  DEPLOY_ENV: ['dev', 'test', 'prod'] → 部署 3 次
+                note: "数组表示对同一个 Job 进行多次部署,每次使用数组中的一个值"
+              
+              - type: "字符串(如 'test')"
+                action: "部署一次,传递该值"
+                example: "ENV: 'test' → 调用 Jenkins Job,传递 {ENV: 'test'}"
+              
+              - type: "其他类型(数字、对象等)"
+                action: "直接作为 Jenkins 构建参数传递"
+                example: "BUILD_NAME: 'build:dev' → 传递 {BUILD_NAME: 'build:dev'}"
           
-          - condition: "参数值为空字符串或空数组"
+          - condition: "参数值为空字符串 '' 或空数组 [] 或空对象 {}"
             action: "进入交互流程,让用户选择"
+            note: "只有参数值为空时才询问用户"
     
     interaction_rules:
       - "全面暂停:一旦检测到任何需要交互的参数,立即暂停所有后续执行流程"
@@ -277,16 +298,65 @@ steps:
     execution_mode: "顺序执行,严禁并行"
     
     multi_env_flow: |
-      环境1 → 交互(如需要) → 部署 → 完成
-        ↓
-      环境2 → 交互(如需要) → 部署 → 完成
-        ↓
-      环境3 → 交互(如需要) → 部署 → 完成
+      检查params配置 → 有值直接部署 / 空值才交互 → 完成
+    
+    multi_env_example: |
+      场景A: config.yaml 中某参数为数组
+        jenkins:
+          'dev':
+            fullname: "dev-platforms-advertiser"
+            params:
+              ENV: ['test', 'pre']
+              BUILD_NAME: "build:dev"
+        
+        执行流程:
+          → 读取 params.ENV = ['test', 'pre'] (数组)
+          → 使用同一个 Jenkins Job (dev-platforms-advertiser) 依次部署:
+            第 1 次: 传递参数 {ENV: 'test', BUILD_NAME: 'build:dev'}
+            第 2 次: 传递参数 {ENV: 'pre', BUILD_NAME: 'build:dev'}
+          → 不询问用户,直接依次部署
+      
+      场景B: config.yaml 中某参数为字符串
+        jenkins:
+          'dev':
+            fullname: "dev-platforms-advertiser"
+            params:
+              ENV: 'test'
+        
+        执行流程:
+          → 读取 params.ENV = 'test' (字符串)
+          → 使用 Jenkins Job (dev-platforms-advertiser) 部署一次
+          → 传递参数 {ENV: 'test'}
+          → 不询问用户,直接部署
+      
+      场景C: config.yaml 中 ENV 参数为空
+        jenkins:
+          'dev':
+            fullname: "dev-platforms-advertiser"
+            params:
+              ENV: []
+        
+        执行流程:
+          → 读取 params.ENV = [] (空数组)
+          → 进入交互流程,询问用户选择部署环境
+          → 等待用户选择后继续
+          → 触发构建
+      
+      场景D: config.yaml 中未配置 params
+        jenkins:
+          'dev':
+            fullname: "dev-platforms-advertiser"
+        
+        执行流程:
+          → 未配置 params
+          → 使用 buildWithParameters + {} 触发构建
+          → Jenkins 使用所有参数默认值
+          → 部署完成
     
     rules:
-      - "逐个遍历环境:一次只处理一个环境,严禁一次性收集所有环境的交互参数"
-      - "只有当前环境部署完成后,才能继续下一个环境"
-      - "各环境独立:比如 test 环境未配置 params 时,应直接使用 Jenkins 默认值"
+      - "参数有值直接部署:只要 config.yaml 中 params 的参数值非空,直接传递给 Jenkins,不询问"
+      - "参数为空才询问:只有参数值为空字符串、空数组或空对象时,才进入交互流程"
+      - "未配置params时:使用 buildWithParameters + {} 触发,Jenkins 使用默认值"
     
     single_env_steps:
       - step: 3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "postar-pipe-mcp",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Unified CI/CD MCP Server - orchestrates GitLab and Jenkins MCPs with dynamic skills",
   "type": "module",
   "main": "dist/index.js",