snow-flow 10.0.1-dev.445 → 10.0.1-dev.447

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "10.0.1-dev.445",
+  "version": "10.0.1-dev.447",
   "name": "snow-flow",
   "description": "Snow-Flow - ServiceNow Multi-Agent Development Framework powered by AI",
   "license": "Elastic-2.0",

package/src/servicenow/servicenow-mcp-unified/tools/flow-designer/snow_manage_flow.ts

@@ -38,6 +38,25 @@ function generateUUID(): string {
   });
 }
 
+async function getNextOrder(client: any, flowId: string): Promise<number> {
+  let maxOrder = 0;
+  // Query all element types that have an order field on this flow
+  for (const table of ['sys_hub_action_instance', 'sys_hub_flow_logic', 'sys_hub_sub_flow_instance']) {
+    try {
+      const resp = await client.get('/api/now/table/' + table, {
+        params: {
+          sysparm_query: 'flow=' + flowId + '^ORDERBYDESCorder',
+          sysparm_fields: 'order',
+          sysparm_limit: 1
+        }
+      });
+      const order = parseInt(resp.data.result?.[0]?.order || '0', 10);
+      if (order > maxOrder) maxOrder = order;
+    } catch (_) {}
+  }
+  return maxOrder + 1;
+}
+
 async function executeFlowPatchMutation(
   client: any,
   flowPatch: any,
@@ -183,6 +202,7 @@ async function addActionViaGraphQL(
   actionType: string,
   actionName: string,
   inputs?: Record<string, string>,
+  parentUiId?: string,
   order?: number
 ): Promise<{ success: boolean; actionId?: string; steps?: any; error?: string }> {
   const steps: any = {};
@@ -265,6 +285,7 @@ async function addActionViaGraphQL(
   }
 
   const uuid = generateUUID();
+  const resolvedOrder = order || await getNextOrder(client, flowId);
   const actionResponseFields = 'actions { inserts { sysId uiUniqueIdentifier __typename } updates deletes __typename }';
   try {
     const result = await executeFlowPatchMutation(client, {
@@ -275,11 +296,11 @@ async function addActionViaGraphQL(
           metadata: '{"predicates":[]}',
           flowSysId: flowId,
           generationSource: '',
-          order: String(order || 1),
-          parent: '',
+          order: String(resolvedOrder),
+          parent: parentUiId || '',
           uiUniqueIdentifier: uuid,
           type: 'action',
-          parentUiId: '',
+          parentUiId: parentUiId || '',
           inputs: []
         }]
       }
@@ -365,13 +386,14 @@ async function addFlowLogicViaGraphQL(
   if (!defId) return { success: false, error: 'Flow logic definition not found for: ' + logicType, steps };
 
   const uuid = generateUUID();
+  const resolvedOrder = order || await getNextOrder(client, flowId);
   const logicResponseFields = 'flowLogics { inserts { sysId uiUniqueIdentifier __typename } updates deletes __typename }';
   try {
     const result = await executeFlowPatchMutation(client, {
       flowId: flowId,
       flowLogics: {
         insert: [{
-          order: String(order || 1),
+          order: String(resolvedOrder),
           uiUniqueIdentifier: uuid,
           parent: '',
           metadata: '{"predicates":[]}',
@@ -472,6 +494,7 @@ async function addSubflowCallViaGraphQL(
   if (!subflowName) subflowName = subflowId;
 
   const uuid = generateUUID();
+  const resolvedOrder = order || await getNextOrder(client, flowId);
   const subflowResponseFields = 'subflows { inserts { sysId uiUniqueIdentifier __typename } updates deletes __typename }';
   try {
     const result = await executeFlowPatchMutation(client, {
@@ -482,7 +505,7 @@ async function addSubflowCallViaGraphQL(
           flowSysId: flowId,
           generationSource: '',
           name: subflowName,
-          order: String(order || 1),
+          order: String(resolvedOrder),
           parent: parentUiId || '',
           subflowSysId: subflowSysId,
           uiUniqueIdentifier: uuid,
@@ -521,6 +544,61 @@ async function addSubflowCallViaGraphQL(
   }
 }
 
+// ── GENERIC UPDATE/DELETE for any flow element ───────────────────────
+
+const elementGraphQLMap: Record<string, { key: string; type: string; responseFields: string }> = {
+  action:     { key: 'actions',           type: 'action',    responseFields: 'actions { inserts { sysId uiUniqueIdentifier __typename } updates deletes __typename }' },
+  trigger:    { key: 'triggerInstances',  type: 'trigger',   responseFields: 'triggerInstances { inserts { sysId uiUniqueIdentifier __typename } updates deletes __typename }' },
+  flowlogic:  { key: 'flowLogics',        type: 'flowlogic', responseFields: 'flowLogics { inserts { sysId uiUniqueIdentifier __typename } updates deletes __typename }' },
+  subflow:    { key: 'subflows',          type: 'subflow',   responseFields: 'subflows { inserts { sysId uiUniqueIdentifier __typename } updates deletes __typename }' },
+};
+
+async function updateElementViaGraphQL(
+  client: any,
+  flowId: string,
+  elementType: string,
+  elementId: string,
+  inputs: Record<string, string>
+): Promise<{ success: boolean; steps?: any; error?: string }> {
+  const config = elementGraphQLMap[elementType];
+  if (!config) return { success: false, error: 'Unknown element type: ' + elementType };
+
+  const updateInputs = Object.entries(inputs).map(([name, value]) => ({
+    name,
+    value: { schemaless: false, schemalessValue: '', value: String(value) }
+  }));
+
+  try {
+    await executeFlowPatchMutation(client, {
+      flowId,
+      [config.key]: { update: [{ uiUniqueIdentifier: elementId, type: config.type, inputs: updateInputs }] }
+    }, config.responseFields);
+    return { success: true, steps: { element: elementId, type: elementType, inputs: updateInputs.map(i => i.name) } };
+  } catch (e: any) {
+    return { success: false, error: e.message, steps: { element: elementId, type: elementType } };
+  }
+}
+
+async function deleteElementViaGraphQL(
+  client: any,
+  flowId: string,
+  elementType: string,
+  elementIds: string[]
+): Promise<{ success: boolean; steps?: any; error?: string }> {
+  const config = elementGraphQLMap[elementType];
+  if (!config) return { success: false, error: 'Unknown element type: ' + elementType };
+
+  try {
+    await executeFlowPatchMutation(client, {
+      flowId,
+      [config.key]: { delete: elementIds }
+    }, config.responseFields);
+    return { success: true, steps: { deleted: elementIds, type: elementType } };
+  } catch (e: any) {
+    return { success: false, error: e.message, steps: { elementIds, type: elementType } };
+  }
+}
+
 async function createFlowViaProcessFlowAPI(
   client: any,
   params: {
@@ -629,8 +707,14 @@ export const toolDefinition: MCPToolDefinition = {
     properties: {
       action: {
         type: 'string',
-        enum: ['create', 'create_subflow', 'list', 'get', 'update', 'activate', 'deactivate', 'delete', 'publish', 'add_trigger', 'update_trigger', 'add_action', 'add_flow_logic', 'add_subflow'],
-        description: 'Action to perform. Use add_trigger/add_action/add_flow_logic/add_subflow to add elements, update_trigger to change an existing trigger. Flow logic types: IF, FOR_EACH, DO_UNTIL, SWITCH. add_subflow calls an existing subflow as a step.'
+        enum: [
+          'create', 'create_subflow', 'list', 'get', 'update', 'activate', 'deactivate', 'delete', 'publish',
+          'add_trigger', 'update_trigger', 'delete_trigger',
+          'add_action', 'update_action', 'delete_action',
+          'add_flow_logic', 'update_flow_logic', 'delete_flow_logic',
+          'add_subflow', 'update_subflow', 'delete_subflow'
+        ],
+        description: 'Action to perform. add_*/update_*/delete_* for triggers, actions, flow_logic, subflows. update_trigger replaces the trigger type. update_action/update_flow_logic/update_subflow change input values. delete_* removes elements by element_id.'
       },
 
       flow_id: {
@@ -732,6 +816,14 @@ export const toolDefinition: MCPToolDefinition = {
         type: 'string',
         description: 'Subflow sys_id or name to call as a step (for add_subflow action). Looked up in sys_hub_flow where type=subflow.'
       },
+      element_id: {
+        type: 'string',
+        description: 'Element sys_id or uiUniqueIdentifier for update_*/delete_* actions. For delete_* this can also be a comma-separated list of IDs.'
+      },
+      order: {
+        type: 'number',
+        description: 'Position/order of the element in the flow (for add_* actions). Auto-detected if not provided (appends after last element).'
+      },
       type: {
         type: 'string',
         enum: ['flow', 'subflow', 'all'],
@@ -1651,7 +1743,7 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
         var addActName = args.action_name || args.name || addActType;
         var addActInputs = args.action_inputs || args.inputs || {};
 
-        var addActResult = await addActionViaGraphQL(client, addActFlowId, addActType, addActName, addActInputs);
+        var addActResult = await addActionViaGraphQL(client, addActFlowId, addActType, addActName, addActInputs, args.parent_ui_id, args.order);
 
         var addActSummary = summary();
         if (addActResult.success) {
@@ -1738,6 +1830,62 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
           : createErrorResult(addSubResult.error || 'Failed to add subflow call');
       }
 
+      // ────────────────────────────────────────────────────────────────
+      // UPDATE_ACTION / UPDATE_FLOW_LOGIC / UPDATE_SUBFLOW
+      // ────────────────────────────────────────────────────────────────
+      case 'update_action':
+      case 'update_flow_logic':
+      case 'update_subflow': {
+        if (!args.flow_id) throw new SnowFlowError(ErrorType.VALIDATION_ERROR, 'flow_id is required');
+        if (!args.element_id) throw new SnowFlowError(ErrorType.VALIDATION_ERROR, 'element_id is required (sys_id or uiUniqueIdentifier of the element)');
+        var updElemFlowId = await resolveFlowId(client, args.flow_id);
+        var updElemType = action === 'update_action' ? 'action' : action === 'update_flow_logic' ? 'flowlogic' : 'subflow';
+        var updElemInputs = args.action_inputs || args.logic_inputs || args.inputs || {};
+
+        var updElemResult = await updateElementViaGraphQL(client, updElemFlowId, updElemType, args.element_id, updElemInputs);
+
+        var updElemSummary = summary();
+        if (updElemResult.success) {
+          updElemSummary.success('Element updated').field('Type', updElemType).field('Element', args.element_id);
+        } else {
+          updElemSummary.error('Failed to update element: ' + (updElemResult.error || 'unknown'));
+        }
+        return updElemResult.success
+          ? createSuccessResult({ action, ...updElemResult }, {}, updElemSummary.build())
+          : createErrorResult(updElemResult.error || 'Failed to update element');
+      }
+
+      // ────────────────────────────────────────────────────────────────
+      // DELETE_ACTION / DELETE_FLOW_LOGIC / DELETE_SUBFLOW / DELETE_TRIGGER
+      // ────────────────────────────────────────────────────────────────
+      case 'delete_action':
+      case 'delete_flow_logic':
+      case 'delete_subflow':
+      case 'delete_trigger': {
+        if (!args.flow_id) throw new SnowFlowError(ErrorType.VALIDATION_ERROR, 'flow_id is required');
+        if (!args.element_id) throw new SnowFlowError(ErrorType.VALIDATION_ERROR, 'element_id is required (sys_id(s) to delete, comma-separated for multiple)');
+        var delElemFlowId = await resolveFlowId(client, args.flow_id);
+        var delElemType = action === 'delete_action' ? 'action'
+          : action === 'delete_flow_logic' ? 'flowlogic'
+          : action === 'delete_subflow' ? 'subflow'
+          : 'trigger';
+        var delElemIds = String(args.element_id).split(',').map((id: string) => id.trim());
+
+        // Map 'trigger' to the correct GraphQL key
+        var delGraphQLType = delElemType === 'trigger' ? 'trigger' : delElemType;
+        var delResult = await deleteElementViaGraphQL(client, delElemFlowId, delGraphQLType, delElemIds);
+
+        var delSummary = summary();
+        if (delResult.success) {
+          delSummary.success('Element(s) deleted').field('Type', delElemType).field('Deleted', delElemIds.join(', '));
+        } else {
+          delSummary.error('Failed to delete element: ' + (delResult.error || 'unknown'));
+        }
+        return delResult.success
+          ? createSuccessResult({ action, ...delResult }, {}, delSummary.build())
+          : createErrorResult(delResult.error || 'Failed to delete element');
+      }
+
       default:
         throw new SnowFlowError(ErrorType.VALIDATION_ERROR, 'Unknown action: ' + action);
     }