flowmind 1.5.2 → 1.5.4

package/skills/auto-flow/index.js

@@ -3,6 +3,11 @@
  * Route deployment and workflow requests to the configured workflow MCP adapter.
  */
 
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { callMcpTool } = require('../../core/mcp-http-client');
+
 const BUILTIN_WORKFLOWS = {
   'dev-workflow': {
     name: 'Development Workflow',
@@ -39,6 +44,21 @@ const TOOL_NAMES = {
   listPipelineRuns: 'flowListPipelineRuns'
 };
 
+const LOCAL_PIPELINE_MAP_CANDIDATES = [
+  process.env.FLOWMIND_AUTO_FLOW_MAP,
+  path.join(process.env.FLOWMIND_HOME || process.env.HOME || process.env.USERPROFILE || os.homedir(), '.flowmind', 'source', 'auto-flow-pipeline-map.json'),
+  path.join(process.cwd(), 'source', 'auto-flow-pipeline-map.json'),
+  path.join(__dirname, '..', '..', '..', 'source', 'auto-flow-pipeline-map.json')
+].filter(Boolean);
+
+const ENV_PREFIX_TO_ENV = {
+  test: 'test',
+  dev: 'test',
+  uat: 'uat',
+  gray: 'gray',
+  prod: 'prod'
+};
+
 module.exports = {
   canHandle(input) {
     if (!input) return false;
@@ -53,19 +73,14 @@ module.exports = {
     const workflow = createWorkflowClient(context);
 
     if (params.action === 'define') {
+      const definition = buildWorkflowDefinitionSummary();
       return {
         type: 'result',
         skill: 'auto-flow',
         message: 'Define a workflow in YAML format',
         data: {
           format: 'YAML workflow definition',
-          example: {
-            name: 'My Workflow',
-            steps: [
-              { id: 'step1', action: 'run-command', command: 'echo hello' },
-              { id: 'step2', skill: 'code-review', depends_on: ['step1'] }
-            ]
-          }
+          execution: definition
         },
         input,
         timestamp: new Date().toISOString()
@@ -77,11 +92,26 @@ module.exports = {
     }
 
     if (params.action === 'status') {
-      return executeStatus(workflow, params, input);
+      const execution = await executeStatus(workflow, params, input);
+      return {
+        type: 'result',
+        skill: 'auto-flow',
+        message: 'Workflow status: query completed',
+        data: {
+          action: 'status',
+          provider: workflow.provider,
+          binding: workflow.binding,
+          status: 'completed',
+          mcpServer: getWorkflowMcpServer(workflow),
+          execution: summarizeWorkflowExecution('status', params, execution)
+        },
+        input,
+        timestamp: new Date().toISOString()
+      };
     }
 
     if (params.action === 'deploy' || params.action === 'run') {
-      return executeDeploy(workflow, params, input);
+      return executeDeploy(workflow, params, input, context);
     }
 
     if (params.action === 'list' || params.serviceNames.length > 0) {
@@ -89,15 +119,14 @@ module.exports = {
       return {
         type: 'result',
         skill: 'auto-flow',
-        message: params.serviceNames.length > 0
-          ? `Resolved workflow query for: ${params.serviceNames.join(', ')}`
-          : 'Listing available deployment pipelines',
+        message: 'Workflow status: pipeline lookup completed',
         data: {
           action: 'list',
           provider: workflow.provider,
           binding: workflow.binding,
-          filters: buildListPipelineParams(params),
-          execution
+          status: 'completed',
+          mcpServer: getWorkflowMcpServer(workflow),
+          execution: summarizeWorkflowExecution('list', params, execution)
         },
         input,
         timestamp: new Date().toISOString()
@@ -112,7 +141,7 @@ module.exports = {
         message: `Workflow ready: ${workflowDef.name}`,
         data: {
           workflow: params.workflow,
-          steps: workflowDef.steps,
+          execution: buildBuiltinWorkflowSummary(params.workflow, workflowDef),
           provider: workflow.provider
         },
         input,
@@ -133,7 +162,8 @@ module.exports = {
         ],
         builtinWorkflows: Object.keys(BUILTIN_WORKFLOWS),
         provider: workflow.provider,
-        binding: workflow.binding
+        binding: workflow.binding,
+        execution: buildAutoFlowHintSummary(workflow)
       },
       input,
       timestamp: new Date().toISOString()
@@ -147,7 +177,8 @@ function createWorkflowClient(context) {
     return {
       client: adapter,
       provider: adapter.providerName,
-      binding: context.resourceBinding?.componentType === 'workflow' ? context.resourceBinding : null
+      binding: context.resourceBinding?.componentType === 'workflow' ? context.resourceBinding : null,
+      transportBacked: true
     };
   }
 
@@ -156,33 +187,394 @@ function createWorkflowClient(context) {
     : null;
 
   if (!binding?.mcpServer) {
-    return { client: null, provider: null, binding: null };
+    return { client: null, provider: null, binding: null, transportBacked: false };
+  }
+
+  const transport = buildWorkflowTransport(binding);
+  if (!transport.url) {
+    return { client: null, provider: binding.provider || null, binding, transportBacked: false };
   }
 
   return {
     client: {
       providerName: binding.provider || 'workflow-binding',
       async listPipelines(params) {
-        return { mcpServer: binding.mcpServer, tool: TOOL_NAMES.listPipelines, params };
+        return callWorkflowMcp(binding, transport, TOOL_NAMES.listPipelines, params);
+      },
+      async getCurrentIterate() {
+        return callWorkflowMcp(binding, transport, 'getCurrentIterate', {});
+      },
+      async listDeployChecklists(params) {
+        return callWorkflowMcp(binding, transport, 'listDeployChecklists', params);
+      },
+      async orderList(params) {
+        return callWorkflowMcp(binding, transport, 'orderList', params);
       },
       async startPipelineRun(pipelineId) {
-        return { mcpServer: binding.mcpServer, tool: TOOL_NAMES.startPipelineRun, params: { pipelineId } };
+        return callWorkflowMcp(binding, transport, TOOL_NAMES.startPipelineRun, { pipelineId });
       },
       async startBatchPipelineRun(params) {
-        return { mcpServer: binding.mcpServer, tool: TOOL_NAMES.startBatchPipelineRun, params };
+        return callWorkflowMcp(binding, transport, TOOL_NAMES.startBatchPipelineRun, params);
       },
       async getPipelineRun(pipelineId, runId) {
-        return { mcpServer: binding.mcpServer, tool: TOOL_NAMES.getPipelineRun, params: { pipelineId, pipelineRunId: runId } };
+        return callWorkflowMcp(binding, transport, TOOL_NAMES.getPipelineRun, { pipelineId, pipelineRunId: runId });
       },
       async listPipelineRuns(pipelineId, params) {
-        return { mcpServer: binding.mcpServer, tool: TOOL_NAMES.listPipelineRuns, params: { pipelineId, ...(params || {}) } };
+        return callWorkflowMcp(binding, transport, TOOL_NAMES.listPipelineRuns, { pipelineId, ...(params || {}) });
       }
     },
     provider: binding.provider || 'workflow-binding',
-    binding
+    binding,
+    transportBacked: true
+  };
+}
+
+function buildWorkflowTransport(binding) {
+  const connection = binding?.connection || {};
+  const headers = {};
+
+  if (connection.token) {
+    headers.Authorization = `Bearer ${connection.token}`;
+  }
+  if (connection.apiKey) {
+    headers['X-API-Key'] = connection.apiKey;
+  }
+
+  return {
+    url: connection.url || connection.address || connection.endpoint || null,
+    headers,
+    timeoutMs: connection.timeoutMs || 60000
   };
 }
 
+function callWorkflowMcp(binding, transport, tool, params) {
+  return callMcpTool({
+    url: transport.url,
+    headers: transport.headers,
+    tool,
+    args: params || {},
+    timeoutMs: transport.timeoutMs || 60000,
+    serverName: binding.mcpServer || binding.provider || 'workflow'
+  });
+}
+
+function summarizeWorkflowExecution(action, params, execution) {
+  const payload = unwrapMcpResult(execution);
+  const records = extractRecords(payload);
+  const total = extractTotalCount(payload, records);
+
+  return compactObject({
+    action,
+    summary: buildWorkflowSummaryText(action, params, total, records),
+    total,
+    status: extractWorkflowStatus(payload, action),
+    target: buildWorkflowTargetLabel(params),
+    environment: params.environment || null,
+    items: records.slice(0, 5).map((record) => summarizeWorkflowRecord(record))
+  });
+}
+
+function summarizeDeployExecution(params, execution, context = {}) {
+  const payload = unwrapMcpResult(execution);
+  const payloadList = Array.isArray(payload) ? payload : [payload];
+  const primary = payloadList.find((item) => item !== null && item !== undefined) || null;
+  const summaryTarget = buildWorkflowTargetLabel(params) || buildDeployTargetLabel(context) || 'deployment';
+
+  return compactObject({
+    action: 'deploy',
+    summary: buildDeploySummaryText(summaryTarget, primary, context, payloadList.length),
+    status: extractDeployStatus(primary),
+    target: summaryTarget,
+    pipelineId: context.pipelineId || params.pipelineId || (Array.isArray(context.pipelineIds) && context.pipelineIds.length === 1 ? context.pipelineIds[0] : null),
+    pipelineIds: Array.isArray(context.pipelineIds) && context.pipelineIds.length > 0 ? context.pipelineIds : null,
+    source: context.source || null,
+    runId: extractDeployRunId(primary),
+    count: payloadList.length > 1 ? payloadList.length : null,
+    details: summarizeDeployDetails(primary)
+  });
+}
+
+function buildWorkflowDefinitionSummary() {
+  return {
+    action: 'define',
+    summary: 'Prepared a YAML workflow template',
+    format: 'YAML workflow definition',
+    example: {
+      name: 'My Workflow',
+      steps: [
+        { id: 'step1', action: 'run-command', command: 'echo hello' },
+        { id: 'step2', skill: 'code-review', depends_on: ['step1'] }
+      ]
+    }
+  };
+}
+
+function buildBuiltinWorkflowSummary(workflowName, workflowDef) {
+  return {
+    action: 'workflow',
+    summary: `Workflow ready: ${workflowDef.name}`,
+    workflow: workflowName,
+    name: workflowDef.name,
+    stepCount: Array.isArray(workflowDef.steps) ? workflowDef.steps.length : 0,
+    steps: (workflowDef.steps || []).map((step) => compactObject({
+      id: step.id,
+      skill: step.skill || null,
+      action: step.action || null,
+      name: step.name || null,
+      depends_on: Array.isArray(step.depends_on) ? step.depends_on : null
+    }))
+  };
+}
+
+function buildAutoFlowHintSummary(workflow) {
+  return {
+    action: 'hint',
+    summary: workflow?.binding
+      ? `Workflow service bound to ${workflow.binding.mcpServer}`
+      : 'Workflow service not configured',
+    provider: workflow?.provider || null,
+    binding: workflow?.binding || null,
+    configured: !!workflow?.client
+  };
+}
+
+function buildWorkflowSummaryText(action, params, total, records) {
+  const target = buildWorkflowTargetLabel(params) || 'all workflows';
+  const count = typeof total === 'number' ? total : records.length;
+
+  if (action === 'status') {
+    return `Checked ${target}${count !== null ? `, ${count} record(s) found` : ''}`;
+  }
+
+  if (action === 'list') {
+    return `Listed workflows for ${target}${count !== null ? `, ${count} pipeline(s) found` : ''}`;
+  }
+
+  return `Workflow ${action} completed`;
+}
+
+function buildWorkflowTargetLabel(params) {
+  if (params.pipelineId && params.runId) {
+    return `pipeline ${params.pipelineId} / run ${params.runId}`;
+  }
+  if (params.pipelineId) {
+    return `pipeline ${params.pipelineId}`;
+  }
+  if (params.serviceNames?.length > 0) {
+    return params.serviceNames.join(', ');
+  }
+  if (params.workflow) {
+    return params.workflow;
+  }
+  return params.environment || null;
+}
+
+function buildDeployTargetLabel(context) {
+  if (Array.isArray(context.pipelineIds) && context.pipelineIds.length > 0) {
+    return `pipeline ${context.pipelineIds.join(', ')}`;
+  }
+  if (context.pipelineId) {
+    return `pipeline ${context.pipelineId}`;
+  }
+  if (Array.isArray(context.services) && context.services.length > 0) {
+    return context.services.map((item) => item.serviceName || item.service || item.pipelineName || item.pipelineId).filter(Boolean).join(', ');
+  }
+  return null;
+}
+
+function buildDeploySummaryText(target, payload, context, count = 1) {
+  const status = extractDeployStatus(payload) || 'submitted';
+  const runId = extractDeployRunId(payload);
+  const source = context.source ? ` via ${context.source}` : '';
+  const countSuffix = count > 1 ? ` (${count} items)` : '';
+
+  if (runId) {
+    return `Deployment ${status} for ${target}${source}, run ${runId}${countSuffix}`;
+  }
+
+  return `Deployment ${status} for ${target}${source}${countSuffix}`;
+}
+
+function extractDeployStatus(payload) {
+  if (payload && typeof payload === 'object') {
+    const candidates = [
+      payload.status,
+      payload.state,
+      payload.result?.status,
+      payload.result?.state
+    ].filter(Boolean);
+    if (candidates.length > 0) {
+      return String(candidates[0]);
+    }
+
+    if (payload.submitted === true) {
+      return 'submitted';
+    }
+  }
+
+  return null;
+}
+
+function extractDeployRunId(payload) {
+  if (!payload || typeof payload !== 'object') {
+    return null;
+  }
+
+  const candidates = [
+    payload.pipelineRunId,
+    payload.pipeline_run_id,
+    payload.runId,
+    payload.run_id,
+    payload.result?.pipelineRunId,
+    payload.result?.pipeline_run_id,
+    payload.result?.runId,
+    payload.result?.run_id
+  ];
+
+  for (const candidate of candidates) {
+    if (candidate === null || candidate === undefined || candidate === '') continue;
+    return String(candidate);
+  }
+
+  return null;
+}
+
+function summarizeDeployDetails(payload) {
+  if (!payload || typeof payload !== 'object') {
+    return null;
+  }
+
+  const details = compactObject({
+    submitted: typeof payload.submitted === 'boolean' ? payload.submitted : null,
+    pipelineRunId: payload.pipelineRunId || payload.pipeline_run_id || null,
+    pipelineId: payload.pipelineId || payload.pipeline_id || null,
+    message: payload.message || payload.result?.message || null
+  });
+
+  return Object.keys(details).length > 0 ? details : null;
+}
+
+function unwrapMcpResult(payload) {
+  if (!payload || typeof payload !== 'object') {
+    return payload;
+  }
+
+  const textContent = Array.isArray(payload.content) ? payload.content : payload.result?.content;
+  if (Array.isArray(textContent)) {
+    const textItem = textContent.find((item) => item?.type === 'text' && typeof item.text === 'string');
+    if (textItem?.text) {
+      try {
+        return JSON.parse(textItem.text);
+      } catch (error) {
+        return payload;
+      }
+    }
+  }
+
+  return payload;
+}
+
+function extractRecords(payload) {
+  const normalized = unwrapMcpResult(payload);
+  if (!normalized) return [];
+  if (Array.isArray(normalized)) return normalized;
+
+  const candidates = [
+    normalized.data,
+    normalized.rows,
+    normalized.list,
+    normalized.records,
+    normalized.result?.data,
+    normalized.result?.rows,
+    normalized.result?.list,
+    normalized.result?.records
+  ];
+
+  for (const candidate of candidates) {
+    if (Array.isArray(candidate)) {
+      return candidate;
+    }
+  }
+
+  return [];
+}
+
+function extractTotalCount(payload, records) {
+  if (payload && typeof payload === 'object') {
+    const candidates = [payload.total, payload.count, payload.result?.total, payload.result?.count];
+    for (const candidate of candidates) {
+      if (typeof candidate === 'number' && Number.isFinite(candidate)) {
+        return candidate;
+      }
+      if (typeof candidate === 'string' && candidate.trim() !== '' && !Number.isNaN(Number(candidate))) {
+        return Number(candidate);
+      }
+    }
+  }
+
+  return records.length;
+}
+
+function extractWorkflowStatus(payload, action) {
+  if (payload && typeof payload === 'object') {
+    const candidates = [
+      payload.status,
+      payload.state,
+      payload.result?.status,
+      payload.result?.state
+    ].filter(Boolean);
+    if (candidates.length > 0) {
+      return String(candidates[0]);
+    }
+  }
+
+  return action === 'status' ? 'completed' : 'completed';
+}
+
+function summarizeWorkflowRecord(record) {
+  const fields = parseWorkflowFields(record?.fields);
+  return compactObject({
+    pipelineName: record?.pipelineName || record?.name || fields?.pipelineName || fields?.name || null,
+    pipelineId: record?.pipelineId || fields?.pipelineId || extractIdFromFields(fields) || null,
+    service: extractWorkflowService(fields),
+    status: record?.status || fields?.status || fields?.state || null,
+    env: record?.env || fields?.env || fields?.environment || null
+  });
+}
+
+function parseWorkflowFields(fields) {
+  if (!fields) return null;
+  if (typeof fields === 'object') return fields;
+  if (typeof fields !== 'string') return null;
+
+  try {
+    return JSON.parse(fields);
+  } catch (error) {
+    return null;
+  }
+}
+
+function extractWorkflowService(fields) {
+  if (!fields) return null;
+  if (Array.isArray(fields.service) && fields.service.length > 0) {
+    return fields.service[0];
+  }
+  if (typeof fields.service === 'string') {
+    return fields.service;
+  }
+  return fields.serviceName || fields.service_name || null;
+}
+
+function extractIdFromFields(fields) {
+  if (!fields || typeof fields !== 'object') return null;
+  const candidates = [fields.pipelineId, fields.pipeline_id, fields.id];
+  for (const candidate of candidates) {
+    if (candidate === null || candidate === undefined || candidate === '') continue;
+    return String(candidate);
+  }
+  return null;
+}
+
 function buildNoAdapterResult(input, params) {
   if (params.workflow && BUILTIN_WORKFLOWS[params.workflow]) {
     const workflow = BUILTIN_WORKFLOWS[params.workflow];
@@ -192,7 +584,7 @@ function buildNoAdapterResult(input, params) {
       message: `Workflow ready: ${workflow.name}`,
       data: {
         workflow: params.workflow,
-        steps: workflow.steps
+        execution: buildBuiltinWorkflowSummary(params.workflow, workflow)
       },
       input,
       timestamp: new Date().toISOString()
@@ -204,28 +596,73 @@ function buildNoAdapterResult(input, params) {
     skill: 'auto-flow',
     message: 'Workflow service not configured. Connect friday-auto-flow first.',
     data: {
-      params,
-      hint: 'Run `flowmind resource` to review current bindings, then save one like: `flowmind "绑定发布业务 mcp=friday-auto-flow token=xxx env=uat"`'
+      status: 'not_configured',
+      hint: 'Run `flowmind resource` to review current bindings, then save one like: `flowmind "绑定发布业务 mcp=friday-auto-flow token=xxx env=uat"`',
+      execution: buildAutoFlowHintSummary({
+        client: null,
+        provider: null,
+        binding: null
+      })
     },
     input,
     timestamp: new Date().toISOString()
   };
 }
 
-async function executeDeploy(workflow, params, input) {
+async function executeDeploy(workflow, params, input, context) {
   if (params.pipelineId) {
     const execution = await workflow.client.startPipelineRun(params.pipelineId);
     return {
       type: 'result',
       skill: 'auto-flow',
-      message: `Starting pipeline ${params.pipelineId}`,
+      message: 'Workflow status: deployment submitted',
       data: {
         action: 'deploy',
-        pipelineId: params.pipelineId,
-        environment: params.environment,
         provider: workflow.provider,
         binding: workflow.binding,
-        execution
+        status: 'submitted',
+        mcpServer: getWorkflowMcpServer(workflow),
+        execution: summarizeDeployExecution(params, execution, {
+          source: 'direct-input',
+          pipelineId: params.pipelineId
+        }),
+        resolution: {
+          source: 'direct-input',
+          pipelineId: params.pipelineId
+        }
+      },
+      input,
+      timestamp: new Date().toISOString()
+    };
+  }
+
+  const resolvedTargets = await resolvePipelineTargets(workflow, params, context);
+  if (resolvedTargets.pipelineIds.length > 0) {
+    const executions = [];
+    for (const pipelineId of resolvedTargets.pipelineIds) {
+      executions.push(await workflow.client.startPipelineRun(pipelineId));
+    }
+
+    return {
+      type: 'result',
+      skill: 'auto-flow',
+      message: 'Workflow status: deployment submitted',
+      data: {
+        action: 'deploy',
+        provider: workflow.provider,
+        binding: workflow.binding,
+        status: 'submitted',
+        mcpServer: getWorkflowMcpServer(workflow),
+        execution: summarizeDeployExecution(params, executions.length === 1 ? executions[0] : executions, {
+          source: resolvedTargets.source,
+          pipelineIds: resolvedTargets.pipelineIds,
+          services: resolvedTargets.resolutions
+        }),
+        resolution: {
+          source: resolvedTargets.source,
+          pipelineIds: resolvedTargets.pipelineIds,
+          services: resolvedTargets.resolutions
+        }
       },
       input,
       timestamp: new Date().toISOString()
@@ -233,33 +670,33 @@ async function executeDeploy(workflow, params, input) {
   }
 
   const listParams = buildListPipelineParams(params);
-  const resolveExecution = await workflow.client.listPipelines(listParams);
+  const lookup = await workflow.client.listPipelines(listParams);
   const batchParams = buildBatchRunParams(params);
   const execution = await workflow.client.startBatchPipelineRun(batchParams);
 
-  return {
-    type: 'result',
-    skill: 'auto-flow',
-    message: params.serviceNames.length > 0
-      ? `Prepared deployment for: ${params.serviceNames.join(', ')}`
-      : `Prepared workflow deployment${params.workflow ? `: ${params.workflow}` : ''}`,
-    data: {
-      action: 'deploy',
-      services: params.serviceNames,
-      workflow: params.workflow,
-      environment: params.environment,
-      provider: workflow.provider,
-      binding: workflow.binding,
-      resolution: {
-        filters: listParams,
-        execution: resolveExecution
+    return {
+      type: 'result',
+      skill: 'auto-flow',
+      message: 'Workflow status: deployment submitted',
+      data: {
+        action: 'deploy',
+        provider: workflow.provider,
+        binding: workflow.binding,
+        status: 'submitted',
+        mcpServer: getWorkflowMcpServer(workflow),
+        execution: summarizeDeployExecution(params, execution, {
+          source: 'batch-fallback',
+          lookup
+        }),
+        resolution: {
+          source: 'batch-fallback',
+          lookup
+        }
       },
-      execution
-    },
-    input,
-    timestamp: new Date().toISOString()
-  };
-}
+      input,
+      timestamp: new Date().toISOString()
+    };
+  }
 
 async function executeStatus(workflow, params, input) {
   let execution;
@@ -273,25 +710,7 @@ async function executeStatus(workflow, params, input) {
     execution = await workflow.client.listPipelines(buildListPipelineParams(params));
   }
 
-  return {
-    type: 'result',
-    skill: 'auto-flow',
-    message: params.runId
-      ? `Querying run status for ${params.runId}`
-      : 'Querying pipeline status',
-    data: {
-      action: 'status',
-      services: params.serviceNames,
-      pipelineId: params.pipelineId,
-      runId: params.runId,
-      environment: params.environment,
-      provider: workflow.provider,
-      binding: workflow.binding,
-      execution
-    },
-    input,
-    timestamp: new Date().toISOString()
-  };
+  return execution;
 }
 
 function parseFlowParams(input) {
@@ -337,6 +756,7 @@ function parseFlowParams(input) {
   }
 
   params.serviceNames = extractServiceNames(input);
+  applyPrefixedServiceNormalization(params);
 
   if (!params.workflow && /deploy-workflow|dev-workflow/i.test(input)) {
     params.workflow = input.match(/deploy-workflow|dev-workflow/i)[0];
@@ -394,6 +814,415 @@ function normalizeEnvironment(value) {
   return normalized;
 }
 
+function applyPrefixedServiceNormalization(params) {
+  const normalizedServices = [];
+
+  for (const originalName of params.serviceNames) {
+    const prefixed = splitPrefixedServiceName(originalName);
+    if (prefixed) {
+      if (!params.environment) {
+        params.environment = prefixed.environment;
+      }
+      normalizedServices.push(prefixed.serviceName);
+      continue;
+    }
+    normalizedServices.push(originalName);
+  }
+
+  params.serviceNames = [...new Set(normalizedServices)];
+}
+
+function splitPrefixedServiceName(serviceName) {
+  const match = String(serviceName || '').match(/^(test|dev|uat|gray|prod)-(.+)$/i);
+  if (!match || !match[2] || !match[2].includes('-')) {
+    return null;
+  }
+
+  return {
+    environment: ENV_PREFIX_TO_ENV[match[1].toLowerCase()] || normalizeEnvironment(match[1]),
+    serviceName: match[2]
+  };
+}
+
+async function resolvePipelineTargets(workflow, params, context) {
+  if (params.serviceNames.length === 0) {
+    return { source: null, resolutions: [], pipelineIds: [] };
+  }
+
+  const resolutions = [];
+  let source = null;
+
+  for (const serviceName of params.serviceNames) {
+    const resolution = await resolvePipelineForService(workflow, {
+      serviceName,
+      environment: params.environment,
+      context
+    });
+
+    if (!resolution?.pipelineId) {
+      return { source: null, resolutions: [], pipelineIds: [] };
+    }
+
+    source = source || resolution.source;
+    resolutions.push(resolution);
+  }
+
+  return {
+    source,
+    resolutions,
+    pipelineIds: [...new Set(resolutions.map((item) => String(item.pipelineId)))]
+  };
+}
+
+async function resolvePipelineForService(workflow, { serviceName, environment, context }) {
+  const localResolution = resolveLocalPipelineForService(serviceName, environment, context);
+  if (localResolution) {
+    return localResolution;
+  }
+
+  if (!workflow.transportBacked || typeof workflow.client?.getCurrentIterate !== 'function') {
+    return null;
+  }
+
+  return resolveRemotePipelineForService(workflow.client, serviceName, environment);
+}
+
+function resolveLocalPipelineForService(serviceName, environment, context) {
+  const pipelineMap = readLocalPipelineMap(context);
+  if (!pipelineMap) return null;
+
+  const entry = pipelineMap[serviceName];
+  if (!entry) return null;
+
+  const pipeline = selectPipelineFromEntry(entry, environment);
+  if (!pipeline?.pipelineId) return null;
+
+  return {
+    source: 'local-map',
+    serviceName,
+    environment: environment || inferEnvironmentFromPipelineName(pipeline.pipelineName),
+    pipelineId: String(pipeline.pipelineId),
+    pipelineName: pipeline.pipelineName || null
+  };
+}
+
+function readLocalPipelineMap(context) {
+  if (context?.pipelineMap && typeof context.pipelineMap === 'object') {
+    return context.pipelineMap;
+  }
+
+  for (const candidate of LOCAL_PIPELINE_MAP_CANDIDATES) {
+    if (!candidate || !fs.existsSync(candidate)) continue;
+    try {
+      return JSON.parse(fs.readFileSync(candidate, 'utf8'));
+    } catch (error) {
+      continue;
+    }
+  }
+
+  return null;
+}
+
+function selectPipelineFromEntry(entry, environment) {
+  const preferredKeys = getEnvLookupOrder(environment);
+  for (const key of preferredKeys) {
+    const candidate = normalizePipelineCollection(entry?.[key]);
+    if (candidate.length > 0) {
+      return candidate[0];
+    }
+  }
+
+  for (const value of Object.values(entry || {})) {
+    const candidate = normalizePipelineCollection(value);
+    if (candidate.length > 0) {
+      return candidate[0];
+    }
+  }
+
+  return null;
+}
+
+function normalizePipelineCollection(value) {
+  if (!value) return [];
+  const items = Array.isArray(value) ? value : [value];
+  return items
+    .map((item) => {
+      if (!item) return null;
+      if (typeof item === 'string') {
+        return parsePipelineDescriptor(item);
+      }
+      if (typeof item === 'object' && item.pipelineId) {
+        return {
+          pipelineName: item.pipelineName || item.name || null,
+          pipelineId: String(item.pipelineId)
+        };
+      }
+      return null;
+    })
+    .filter(Boolean);
+}
+
+async function resolveRemotePipelineForService(client, serviceName, environment) {
+  const iterateName = await lookupCurrentIterateName(client);
+  const searchers = [
+    async () => parseRemotePipelineLookup(
+      await client.listDeployChecklists({ pageNum: '1', pageSize: '200', iterate: iterateName }),
+      serviceName,
+      environment,
+      'deploy-checklists'
+    ),
+    async () => parseRemotePipelineLookup(
+      await client.orderList({ pageNum: '1', pageSize: '200', iterateName }),
+      serviceName,
+      environment,
+      'order-list'
+    )
+  ];
+
+  for (const search of searchers) {
+    const resolution = await search();
+    if (resolution?.pipelineId) {
+      return resolution;
+    }
+  }
+
+  return null;
+}
+
+async function lookupCurrentIterateName(client) {
+  const payload = unwrapMcpPayload(await client.getCurrentIterate());
+  if (payload?.name && typeof payload.name === 'string') {
+    return payload.name;
+  }
+  const values = collectNestedValues(payload);
+  const iterateName = values.find((value) => typeof value === 'string' && /\d+\.\d+/.test(value));
+  return iterateName || null;
+}
+
+function parseRemotePipelineLookup(payload, serviceName, environment, source) {
+  const records = extractRecordArray(payload);
+  for (const record of records) {
+    const fields = parseFields(record.fields);
+    if (!fields || !matchesRemoteService(fields, serviceName, environment)) {
+      continue;
+    }
+
+    const pipeline = selectPipelineFromFields(fields, environment, serviceName);
+    if (pipeline?.pipelineId) {
+      return {
+        source,
+        serviceName,
+        environment: environment || inferEnvironmentFromPipelineName(pipeline.pipelineName),
+        pipelineId: String(pipeline.pipelineId),
+        pipelineName: pipeline.pipelineName || null
+      };
+    }
+  }
+
+  return null;
+}
+
+function extractRecordArray(payload) {
+  const normalized = unwrapMcpPayload(payload);
+  if (!normalized) return [];
+  if (Array.isArray(normalized)) return normalized;
+
+  const candidates = [
+    normalized.data,
+    normalized.rows,
+    normalized.list,
+    normalized.records,
+    normalized.result?.data,
+    normalized.result?.rows,
+    normalized.result?.list,
+    normalized.result?.records
+  ];
+
+  for (const candidate of candidates) {
+    if (Array.isArray(candidate)) {
+      return candidate;
+    }
+  }
+
+  return [];
+}
+
+function parseFields(fields) {
+  if (!fields) return null;
+  if (typeof fields === 'object') return fields;
+  if (typeof fields !== 'string') return null;
+
+  try {
+    return JSON.parse(fields);
+  } catch (error) {
+    return null;
+  }
+}
+
+function unwrapMcpPayload(payload) {
+  if (!payload || typeof payload !== 'object') {
+    return payload;
+  }
+
+  const textContent = Array.isArray(payload.content) ? payload.content : payload.result?.content;
+  if (Array.isArray(textContent)) {
+    const textItem = textContent.find((item) => item?.type === 'text' && typeof item.text === 'string');
+    if (textItem?.text) {
+      try {
+        return JSON.parse(textItem.text);
+      } catch (error) {
+        return payload;
+      }
+    }
+  }
+
+  return payload;
+}
+
+function matchesRemoteService(fields, serviceName, environment) {
+  const services = Array.isArray(fields.service) ? fields.service.map((item) => String(item).trim()) : [];
+  if (services.includes(serviceName)) {
+    return true;
+  }
+
+  const expectedPipelineName = buildPrefixedPipelineName(serviceName, environment);
+  const pipelineCandidates = collectFieldPipelineDescriptors(fields, environment)
+    .map((item) => item.pipelineName)
+    .filter(Boolean);
+
+  return expectedPipelineName ? pipelineCandidates.includes(expectedPipelineName) : false;
+}
+
+function selectPipelineFromFields(fields, environment, serviceName) {
+  const indexedCandidate = selectIndexedPipelineForService(fields, environment, serviceName);
+  if (indexedCandidate?.pipelineId) {
+    return indexedCandidate;
+  }
+
+  const candidates = collectFieldPipelineDescriptors(fields, environment);
+  if (candidates.length > 0) {
+    return candidates[0];
+  }
+
+  const pipelineIds = String(fields.pipelineId || '')
+    .split(',')
+    .map((item) => item.trim())
+    .filter(Boolean);
+
+  if (pipelineIds.length === 0) {
+    return null;
+  }
+
+  return {
+    pipelineName: buildPrefixedPipelineName(
+      Array.isArray(fields.service) ? fields.service[0] : null,
+      environment
+    ),
+    pipelineId: pipelineIds[0]
+  };
+}
+
+function selectIndexedPipelineForService(fields, environment, serviceName) {
+  if (!serviceName) return null;
+
+  const services = Array.isArray(fields.service) ? fields.service.map((item) => String(item).trim()) : [];
+  const serviceIndex = services.indexOf(serviceName);
+  if (serviceIndex < 0) return null;
+
+  for (const key of getFieldKeysForEnvironment(environment)) {
+    const values = Array.isArray(fields[key]) ? fields[key] : [];
+    const parsed = parsePipelineDescriptor(values[serviceIndex]);
+    if (parsed?.pipelineId) {
+      return parsed;
+    }
+  }
+
+  return null;
+}
+
+function collectFieldPipelineDescriptors(fields, environment) {
+  const keys = getFieldKeysForEnvironment(environment);
+  const results = [];
+
+  for (const key of keys) {
+    const values = Array.isArray(fields[key]) ? fields[key] : (fields[key] ? [fields[key]] : []);
+    for (const value of values) {
+      const parsed = parsePipelineDescriptor(value);
+      if (parsed?.pipelineId) {
+        results.push(parsed);
+      }
+    }
+  }
+
+  return results;
+}
+
+function getFieldKeysForEnvironment(environment) {
+  const normalized = normalizeEnvironment(environment || '');
+  if (normalized === 'prod') return ['prodPipeline', 'pipeline'];
+  if (normalized === 'gray') return ['grayPipeline', 'prodPipeline', 'pipeline'];
+  return ['pipeline', 'grayPipeline', 'prodPipeline'];
+}
+
+function parsePipelineDescriptor(value) {
+  if (!value) return null;
+  const parts = String(value).split('#@').map((item) => item.trim()).filter(Boolean);
+  if (parts.length < 2) return null;
+  return {
+    pipelineName: parts[0] || null,
+    pipelineId: parts[1] || null
+  };
+}
+
+function getEnvLookupOrder(environment) {
+  const normalized = normalizeEnvironment(environment || '');
+  if (normalized === 'prod') return ['prod'];
+  if (normalized === 'gray') return ['gray', 'prod'];
+  if (normalized === 'uat') return ['uat'];
+  if (normalized === 'test') return ['test', 'dev', 'uat'];
+  return ['uat', 'test', 'dev', 'gray', 'prod'];
+}
+
+function buildPrefixedPipelineName(serviceName, environment) {
+  if (!serviceName) return null;
+  const normalized = normalizeEnvironment(environment || '');
+  if (!normalized) return null;
+  const prefix = normalized === 'test' ? 'test' : normalized;
+  return `${prefix}-${serviceName}`;
+}
+
+function inferEnvironmentFromPipelineName(pipelineName) {
+  const match = String(pipelineName || '').match(/^(test|dev|uat|gray|prod)-/i);
+  return match ? (ENV_PREFIX_TO_ENV[match[1].toLowerCase()] || normalizeEnvironment(match[1])) : null;
+}
+
+function collectNestedValues(payload, values = []) {
+  if (payload == null) {
+    return values;
+  }
+
+  if (Array.isArray(payload)) {
+    for (const item of payload) {
+      collectNestedValues(item, values);
+    }
+    return values;
+  }
+
+  if (typeof payload === 'object') {
+    for (const value of Object.values(payload)) {
+      collectNestedValues(value, values);
+    }
+    return values;
+  }
+
+  values.push(payload);
+  return values;
+}
+
 function compactObject(value) {
   return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined && item !== null && item !== ''));
 }
+
+function getWorkflowMcpServer(workflow) {
+  return workflow.client?.mcpServer || workflow.binding?.mcpServer || workflow.provider;
+}