flowmind 1.5.1 → 1.5.3

package/skills/auto-flow/index.js

@@ -3,6 +3,10 @@
  * Route deployment and workflow requests to the configured workflow MCP adapter.
  */
 
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
 const BUILTIN_WORKFLOWS = {
   'dev-workflow': {
     name: 'Development Workflow',
@@ -39,6 +43,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;
@@ -77,27 +96,39 @@ module.exports = {
     }
 
     if (params.action === 'status') {
-      return executeStatus(workflow, params, input);
+      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)
+        },
+        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) {
-      const execution = await workflow.client.listPipelines(buildListPipelineParams(params));
+      await workflow.client.listPipelines(buildListPipelineParams(params));
       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)
         },
         input,
         timestamp: new Date().toISOString()
@@ -147,7 +178,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,7 +188,7 @@ function createWorkflowClient(context) {
     : null;
 
   if (!binding?.mcpServer) {
-    return { client: null, provider: null, binding: null };
+    return { client: null, provider: null, binding: null, transportBacked: false };
   }
 
   return {
@@ -165,6 +197,15 @@ function createWorkflowClient(context) {
       async listPipelines(params) {
         return { mcpServer: binding.mcpServer, tool: TOOL_NAMES.listPipelines, params };
       },
+      async getCurrentIterate() {
+        return { mcpServer: binding.mcpServer, tool: 'getCurrentIterate', params: {} };
+      },
+      async listDeployChecklists(params) {
+        return { mcpServer: binding.mcpServer, tool: 'listDeployChecklists', params };
+      },
+      async orderList(params) {
+        return { mcpServer: binding.mcpServer, tool: 'orderList', params };
+      },
       async startPipelineRun(pipelineId) {
         return { mcpServer: binding.mcpServer, tool: TOOL_NAMES.startPipelineRun, params: { pipelineId } };
       },
@@ -179,7 +220,8 @@ function createWorkflowClient(context) {
       }
     },
     provider: binding.provider || 'workflow-binding',
-    binding
+    binding,
+    transportBacked: false
   };
 }
 
@@ -204,7 +246,7 @@ function buildNoAdapterResult(input, params) {
     skill: 'auto-flow',
     message: 'Workflow service not configured. Connect friday-auto-flow first.',
     data: {
-      params,
+      status: 'not_configured',
       hint: 'Run `flowmind resource` to review current bindings, then save one like: `flowmind "绑定发布业务 mcp=friday-auto-flow token=xxx env=uat"`'
     },
     input,
@@ -212,20 +254,53 @@ function buildNoAdapterResult(input, params) {
   };
 }
 
-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',
+        provider: workflow.provider,
+        binding: workflow.binding,
+        status: 'submitted',
+        mcpServer: getWorkflowMcpServer(workflow),
+        execution,
+        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',
-        pipelineId: params.pipelineId,
-        environment: params.environment,
         provider: workflow.provider,
         binding: workflow.binding,
-        execution
+        status: 'submitted',
+        mcpServer: getWorkflowMcpServer(workflow),
+        execution: executions.length === 1 ? executions[0] : executions,
+        resolution: {
+          source: resolvedTargets.source,
+          pipelineIds: resolvedTargets.pipelineIds,
+          services: resolvedTargets.resolutions
+        }
       },
       input,
       timestamp: new Date().toISOString()
@@ -233,61 +308,52 @@ 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,
+        resolution: {
+          source: 'batch-fallback',
+          lookup
+        }
       },
-      execution
-    },
-    input,
-    timestamp: new Date().toISOString()
-  };
-}
+      input,
+      timestamp: new Date().toISOString()
+    };
+  }
 
 async function executeStatus(workflow, params, input) {
-  let execution;
   if (params.pipelineId && params.runId) {
-    execution = await workflow.client.getPipelineRun(params.pipelineId, params.runId);
+    await workflow.client.getPipelineRun(params.pipelineId, params.runId);
   } else if (params.pipelineId) {
-    execution = await workflow.client.listPipelineRuns(params.pipelineId, {
+    await workflow.client.listPipelineRuns(params.pipelineId, {
       env: params.environment
     });
   } else {
-    execution = await workflow.client.listPipelines(buildListPipelineParams(params));
+    await workflow.client.listPipelines(buildListPipelineParams(params));
   }
 
   return {
     type: 'result',
     skill: 'auto-flow',
-    message: params.runId
-      ? `Querying run status for ${params.runId}`
-      : 'Querying pipeline status',
+    message: 'Workflow status: query completed',
     data: {
       action: 'status',
-      services: params.serviceNames,
-      pipelineId: params.pipelineId,
-      runId: params.runId,
-      environment: params.environment,
       provider: workflow.provider,
       binding: workflow.binding,
-      execution
+      status: 'completed',
+      mcpServer: workflow.binding?.mcpServer || workflow.provider
     },
     input,
     timestamp: new Date().toISOString()
@@ -337,6 +403,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 +461,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;
+}