snow-flow 10.0.1-dev.361 → 10.0.1-dev.388

package/package.json

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

package/src/servicenow/servicenow-mcp-unified/shared/tool-registry.ts

@@ -82,6 +82,7 @@ import * as integrationTools from '../tools/integration/index.js';
 import * as platformTools from '../tools/platform/index.js';
 import * as devopsTools from '../tools/devops/index.js';
 import * as virtualAgentTools from '../tools/virtual-agent/index.js';
+import * as flowDesignerTools from '../tools/flow-designer/index.js';
 
 // ES Module compatible __dirname
 const __filename = fileURLToPath(import.meta.url);
@@ -148,6 +149,7 @@ const STATIC_TOOL_MODULES: Record<string, any> = {
   'platform': platformTools,
   'devops': devopsTools,
   'virtual-agent': virtualAgentTools,
+  'flow-designer': flowDesignerTools,
 };
 
 export class ToolRegistry {

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

@@ -0,0 +1,5 @@
+/**
+ * Flow Designer Tools - Export all flow designer tool modules
+ */
+
+export { toolDefinition as snow_manage_flow_def, execute as snow_manage_flow_exec } from './snow_manage_flow.js';

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

@@ -0,0 +1,867 @@
+/**
+ * snow_manage_flow - Complete Flow Designer lifecycle management
+ *
+ * Create, list, get, update, activate, deactivate, delete and publish
+ * Flow Designer flows and subflows via Table API with background script fallback.
+ *
+ * ServiceNow does NOT expose a public Flow Designer creation API.
+ * This tool uses the Table API (sys_hub_flow) with a GlideRecord fallback
+ * when the caller lacks direct table write permissions (403).
+ */
+
+import { MCPToolDefinition, ServiceNowContext, ToolResult } from '../../shared/types.js';
+import { getAuthenticatedClient } from '../../shared/auth.js';
+import { createSuccessResult, createErrorResult, SnowFlowError, ErrorType } from '../../shared/error-handler.js';
+import { summary } from '../../shared/output-formatter.js';
+
+// ── helpers ────────────────────────────────────────────────────────────
+
+function sanitizeInternalName(name: string): string {
+  return name
+    .toLowerCase()
+    .replace(/[^a-z0-9_]/g, '_')
+    .replace(/_+/g, '_')
+    .replace(/^_|_$/g, '');
+}
+
+function isSysId(value: string): boolean {
+  return /^[a-f0-9]{32}$/.test(value);
+}
+
+/**
+ * Resolve a flow name to its sys_id. If the value is already a 32-char hex
+ * string it is returned as-is.
+ */
+async function resolveFlowId(client: any, flowId: string): Promise<string> {
+  if (isSysId(flowId)) return flowId;
+
+  var lookup = await client.get('/api/now/table/sys_hub_flow', {
+    params: {
+      sysparm_query: 'name=' + flowId,
+      sysparm_fields: 'sys_id',
+      sysparm_limit: 1
+    }
+  });
+
+  if (!lookup.data.result || lookup.data.result.length === 0) {
+    throw new SnowFlowError(ErrorType.NOT_FOUND, 'Flow not found: ' + flowId);
+  }
+  return lookup.data.result[0].sys_id;
+}
+
+// ── tool definition ────────────────────────────────────────────────────
+
+export const toolDefinition: MCPToolDefinition = {
+  name: 'snow_manage_flow',
+  description: 'Complete Flow Designer lifecycle: create flows/subflows, list, get details, update, activate, deactivate, delete and publish',
+  category: 'automation',
+  subcategory: 'flow-designer',
+  use_cases: ['flow-designer', 'automation', 'flow-management', 'subflow'],
+  complexity: 'advanced',
+  frequency: 'high',
+  permission: 'write',
+  allowedRoles: ['developer', 'admin'],
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: {
+        type: 'string',
+        enum: ['create', 'create_subflow', 'list', 'get', 'update', 'activate', 'deactivate', 'delete', 'publish'],
+        description: 'Action to perform'
+      },
+
+      // ── shared identifiers ──
+      flow_id: {
+        type: 'string',
+        description: 'Flow sys_id or name (required for get, update, activate, deactivate, delete, publish)'
+      },
+
+      // ── create / create_subflow params ──
+      name: {
+        type: 'string',
+        description: 'Flow name (required for create / create_subflow)'
+      },
+      description: {
+        type: 'string',
+        description: 'Flow description'
+      },
+      trigger_type: {
+        type: 'string',
+        enum: ['record_created', 'record_updated', 'scheduled', 'manual'],
+        description: 'Trigger type (create only, default: manual)',
+        default: 'manual'
+      },
+      table: {
+        type: 'string',
+        description: 'Table for record-based triggers (e.g. "incident") or list filter'
+      },
+      trigger_condition: {
+        type: 'string',
+        description: 'Encoded query condition for the trigger'
+      },
+      category: {
+        type: 'string',
+        description: 'Flow category',
+        default: 'custom'
+      },
+      run_as: {
+        type: 'string',
+        enum: ['user', 'system'],
+        description: 'Run-as context (default: user)',
+        default: 'user'
+      },
+      activities: {
+        type: 'array',
+        description: 'Flow action steps',
+        items: {
+          type: 'object',
+          properties: {
+            name: { type: 'string', description: 'Step name' },
+            type: {
+              type: 'string',
+              enum: ['notification', 'field_update', 'create_record', 'script', 'log', 'wait', 'approval'],
+              description: 'Action type'
+            },
+            inputs: { type: 'object', description: 'Step-specific input values' }
+          }
+        }
+      },
+      inputs: {
+        type: 'array',
+        description: 'Flow input variables',
+        items: {
+          type: 'object',
+          properties: {
+            name: { type: 'string' },
+            label: { type: 'string' },
+            type: { type: 'string', enum: ['string', 'integer', 'boolean', 'reference', 'object', 'array'] },
+            mandatory: { type: 'boolean' },
+            default_value: { type: 'string' }
+          }
+        }
+      },
+      outputs: {
+        type: 'array',
+        description: 'Flow output variables',
+        items: {
+          type: 'object',
+          properties: {
+            name: { type: 'string' },
+            label: { type: 'string' },
+            type: { type: 'string', enum: ['string', 'integer', 'boolean', 'reference', 'object', 'array'] }
+          }
+        }
+      },
+      activate: {
+        type: 'boolean',
+        description: 'Activate flow after creation (default: true)',
+        default: true
+      },
+
+      // ── list params ──
+      type: {
+        type: 'string',
+        enum: ['flow', 'subflow', 'all'],
+        description: 'Filter by type (list only, default: all)',
+        default: 'all'
+      },
+      active_only: {
+        type: 'boolean',
+        description: 'Only list active flows (default: true)',
+        default: true
+      },
+      limit: {
+        type: 'number',
+        description: 'Max results for list',
+        default: 50
+      },
+
+      // ── update params ──
+      update_fields: {
+        type: 'object',
+        description: 'Fields to update (for update action)',
+        properties: {
+          name: { type: 'string' },
+          description: { type: 'string' },
+          category: { type: 'string' },
+          run_as: { type: 'string' }
+        }
+      }
+    },
+    required: ['action']
+  }
+};
+
+// ── execute ────────────────────────────────────────────────────────────
+
+export async function execute(args: any, context: ServiceNowContext): Promise<ToolResult> {
+  var action = args.action;
+
+  try {
+    var client = await getAuthenticatedClient(context);
+
+    switch (action) {
+
+      // ────────────────────────────────────────────────────────────────
+      // CREATE
+      // ────────────────────────────────────────────────────────────────
+      case 'create':
+      case 'create_subflow': {
+        var flowName = args.name;
+        if (!flowName) {
+          throw new SnowFlowError(ErrorType.VALIDATION_ERROR, 'name is required for ' + action);
+        }
+
+        var isSubflow = action === 'create_subflow';
+        var flowDescription = args.description || flowName;
+        var triggerType = isSubflow ? 'manual' : (args.trigger_type || 'manual');
+        var flowTable = args.table || '';
+        var triggerCondition = args.trigger_condition || '';
+        var flowCategory = args.category || 'custom';
+        var flowRunAs = isSubflow ? 'user_who_calls' : (args.run_as || 'user');
+        var activitiesArg = args.activities || [];
+        var inputsArg = args.inputs || [];
+        var outputsArg = args.outputs || [];
+        var shouldActivate = args.activate !== false;
+        var usedBackgroundScript = false;
+
+        // Build flow_definition JSON
+        var flowDefinition: any = {
+          name: flowName,
+          description: flowDescription,
+          trigger: {
+            type: triggerType,
+            table: flowTable,
+            condition: triggerCondition
+          },
+          activities: activitiesArg.map(function (act: any, idx: number) {
+            return {
+              name: act.name,
+              label: act.name,
+              type: act.type || 'script',
+              inputs: act.inputs || {},
+              order: (idx + 1) * 100,
+              active: true
+            };
+          }),
+          inputs: inputsArg.map(function (inp: any) {
+            return {
+              name: inp.name,
+              label: inp.label || inp.name,
+              type: inp.type || 'string',
+              mandatory: inp.mandatory || false,
+              default_value: inp.default_value || ''
+            };
+          }),
+          outputs: outputsArg.map(function (out: any) {
+            return {
+              name: out.name,
+              label: out.label || out.name,
+              type: out.type || 'string'
+            };
+          }),
+          version: '1.0'
+        };
+
+        // Remove trigger block for subflows
+        if (isSubflow) {
+          delete flowDefinition.trigger;
+        }
+
+        var flowData: any = {
+          name: flowName,
+          description: flowDescription,
+          active: shouldActivate,
+          internal_name: sanitizeInternalName(flowName),
+          category: flowCategory,
+          run_as: flowRunAs,
+          status: shouldActivate ? 'published' : 'draft',
+          validated: true,
+          type: isSubflow ? 'subflow' : 'flow',
+          flow_definition: JSON.stringify(flowDefinition),
+          latest_snapshot: JSON.stringify(flowDefinition)
+        };
+
+        // 1. Create flow record via Table API (with 403 fallback)
+        var flowResponse: any;
+        try {
+          flowResponse = await client.post('/api/now/table/sys_hub_flow', flowData);
+        } catch (tableError: any) {
+          if (tableError.response?.status === 403) {
+            usedBackgroundScript = true;
+            var createScript = [
+              "var gr = new GlideRecord('sys_hub_flow');",
+              "gr.initialize();",
+              "gr.name = " + JSON.stringify(flowName) + ";",
+              "gr.description = " + JSON.stringify(flowDescription) + ";",
+              "gr.active = " + shouldActivate + ";",
+              "gr.internal_name = " + JSON.stringify(sanitizeInternalName(flowName)) + ";",
+              "gr.category = " + JSON.stringify(flowCategory) + ";",
+              "gr.run_as = " + JSON.stringify(flowRunAs) + ";",
+              "gr.status = " + JSON.stringify(shouldActivate ? 'published' : 'draft') + ";",
+              "gr.validated = true;",
+              "gr.type = " + JSON.stringify(isSubflow ? 'subflow' : 'flow') + ";",
+              "gr.flow_definition = " + JSON.stringify(JSON.stringify(flowDefinition)) + ";",
+              "gr.latest_snapshot = " + JSON.stringify(JSON.stringify(flowDefinition)) + ";",
+              "var sysId = gr.insert();",
+              "if (sysId) {",
+              "  gs.print(JSON.stringify({ sys_id: sysId, name: gr.name.toString() }));",
+              "} else {",
+              "  gs.error('Failed to create flow');",
+              "}"
+            ].join('\n');
+
+            var scriptResp = await client.post('/api/now/table/sys_script_execution', {
+              script: createScript,
+              description: 'Create Flow: ' + flowName
+            });
+
+            var scriptOutput = scriptResp.data.result?.output || '';
+            var scriptMatch = scriptOutput.match(/\{[^}]+\}/);
+            if (scriptMatch) {
+              flowResponse = { data: { result: JSON.parse(scriptMatch[0]) } };
+            } else {
+              throw new Error('Failed to create flow via background script. Output: ' + scriptOutput);
+            }
+          } else {
+            throw tableError;
+          }
+        }
+
+        var createdFlow = flowResponse.data.result;
+        var flowSysId = createdFlow.sys_id;
+
+        // 2. Create trigger instance (non-manual flows only)
+        var triggerCreated = false;
+        if (!isSubflow && triggerType !== 'manual') {
+          try {
+            // Lookup trigger action type
+            var triggerTypeLookup: Record<string, string> = {
+              'record_created': 'sn_fd.trigger.record_created',
+              'record_updated': 'sn_fd.trigger.record_updated',
+              'scheduled': 'sn_fd.trigger.scheduled'
+            };
+            var triggerInternalName = triggerTypeLookup[triggerType] || '';
+
+            if (triggerInternalName) {
+              var triggerDefResp = await client.get('/api/now/table/sys_hub_action_type_definition', {
+                params: {
+                  sysparm_query: 'internal_name=' + triggerInternalName,
+                  sysparm_fields: 'sys_id',
+                  sysparm_limit: 1
+                }
+              });
+
+              var triggerDefId = triggerDefResp.data.result?.[0]?.sys_id;
+              if (triggerDefId) {
+                var triggerData: any = {
+                  flow: flowSysId,
+                  action_type: triggerDefId,
+                  name: triggerType,
+                  order: 0,
+                  active: true
+                };
+                if (flowTable) {
+                  triggerData.table = flowTable;
+                }
+                if (triggerCondition) {
+                  triggerData.condition = triggerCondition;
+                }
+
+                await client.post('/api/now/table/sys_hub_trigger_instance', triggerData);
+                triggerCreated = true;
+              }
+            }
+          } catch (triggerError) {
+            // Trigger creation is best-effort
+          }
+        }
+
+        // 3. Create action instances
+        var actionsCreated = 0;
+        for (var ai = 0; ai < activitiesArg.length; ai++) {
+          var activity = activitiesArg[ai];
+          try {
+            // Lookup action type definition
+            var actionTypeName = activity.type || 'script';
+            var actionTypeQuery = 'internal_nameLIKE' + actionTypeName + '^ORnameLIKE' + actionTypeName;
+
+            var actionDefResp = await client.get('/api/now/table/sys_hub_action_type_definition', {
+              params: {
+                sysparm_query: actionTypeQuery,
+                sysparm_fields: 'sys_id,name,internal_name',
+                sysparm_limit: 1
+              }
+            });
+
+            var actionDefId = actionDefResp.data.result?.[0]?.sys_id;
+            var instanceData: any = {
+              flow: flowSysId,
+              name: activity.name,
+              order: (ai + 1) * 100,
+              active: true
+            };
+            if (actionDefId) {
+              instanceData.action_type = actionDefId;
+            }
+
+            await client.post('/api/now/table/sys_hub_action_instance', instanceData);
+            actionsCreated++;
+          } catch (actError) {
+            // Action creation is best-effort
+          }
+        }
+
+        // 4. Create flow variables (for subflows with inputs/outputs)
+        var varsCreated = 0;
+        if (isSubflow) {
+          for (var vi = 0; vi < inputsArg.length; vi++) {
+            var inp = inputsArg[vi];
+            try {
+              await client.post('/api/now/table/sys_hub_flow_variable', {
+                flow: flowSysId,
+                name: inp.name,
+                label: inp.label || inp.name,
+                type: inp.type || 'string',
+                mandatory: inp.mandatory || false,
+                default_value: inp.default_value || '',
+                variable_type: 'input'
+              });
+              varsCreated++;
+            } catch (varError) {
+              // Best-effort
+            }
+          }
+          for (var vo = 0; vo < outputsArg.length; vo++) {
+            var out = outputsArg[vo];
+            try {
+              await client.post('/api/now/table/sys_hub_flow_variable', {
+                flow: flowSysId,
+                name: out.name,
+                label: out.label || out.name,
+                type: out.type || 'string',
+                variable_type: 'output'
+              });
+              varsCreated++;
+            } catch (varError) {
+              // Best-effort
+            }
+          }
+        }
+
+        // 5. Activate if needed (and not already active from creation)
+        if (shouldActivate && usedBackgroundScript) {
+          try {
+            await client.patch('/api/now/table/sys_hub_flow/' + flowSysId, {
+              active: true,
+              status: 'published',
+              validated: true
+            });
+          } catch (activateError) {
+            // Best-effort
+          }
+        }
+
+        // 6. Best-effort snapshot
+        try {
+          await client.post('/api/sn_flow_designer/flow/snapshot', {
+            flow_id: flowSysId
+          });
+        } catch (snapError) {
+          // Snapshot API may not exist in all instances
+        }
+
+        // Build summary
+        var createSummary = summary()
+          .success('Created ' + (isSubflow ? 'subflow' : 'flow') + ': ' + flowName)
+          .field('sys_id', flowSysId)
+          .field('Type', isSubflow ? 'Subflow' : 'Flow')
+          .field('Category', flowCategory)
+          .field('Status', shouldActivate ? 'Published (active)' : 'Draft')
+          .field('Method', usedBackgroundScript ? 'Background script' : 'Table API');
+
+        if (!isSubflow && triggerType !== 'manual') {
+          createSummary.field('Trigger', triggerType + (triggerCreated ? ' (created)' : ' (best-effort)'));
+          if (flowTable) createSummary.field('Table', flowTable);
+        }
+        if (activitiesArg.length > 0) {
+          createSummary.field('Actions', actionsCreated + '/' + activitiesArg.length + ' created');
+        }
+        if (varsCreated > 0) {
+          createSummary.field('Variables', varsCreated + ' created');
+        }
+
+        return createSuccessResult({
+          created: true,
+          method: usedBackgroundScript ? 'background_script' : 'table_api',
+          flow: {
+            sys_id: flowSysId,
+            name: flowName,
+            type: isSubflow ? 'subflow' : 'flow',
+            category: flowCategory,
+            active: shouldActivate,
+            status: shouldActivate ? 'published' : 'draft'
+          },
+          trigger: !isSubflow && triggerType !== 'manual' ? {
+            type: triggerType,
+            table: flowTable,
+            condition: triggerCondition,
+            created: triggerCreated
+          } : null,
+          activities_created: actionsCreated,
+          activities_requested: activitiesArg.length,
+          variables_created: varsCreated
+        }, {}, createSummary.build());
+      }
+
+      // ────────────────────────────────────────────────────────────────
+      // LIST
+      // ────────────────────────────────────────────────────────────────
+      case 'list': {
+        var listQuery = '';
+        var filterType = args.type || 'all';
+        var activeOnly = args.active_only !== false;
+        var listLimit = args.limit || 50;
+        var filterTable = args.table || '';
+
+        if (filterType !== 'all') {
+          listQuery = 'type=' + filterType;
+        }
+        if (activeOnly) {
+          listQuery += (listQuery ? '^' : '') + 'active=true';
+        }
+        if (filterTable) {
+          listQuery += (listQuery ? '^' : '') + 'flow_definitionLIKE' + filterTable;
+        }
+
+        var listResp = await client.get('/api/now/table/sys_hub_flow', {
+          params: {
+            sysparm_query: listQuery || undefined,
+            sysparm_fields: 'sys_id,name,description,type,category,active,status,run_as,sys_created_on,sys_updated_on',
+            sysparm_limit: listLimit
+          }
+        });
+
+        var flows = (listResp.data.result || []).map(function (f: any) {
+          return {
+            sys_id: f.sys_id,
+            name: f.name,
+            description: f.description,
+            type: f.type,
+            category: f.category,
+            active: f.active === 'true',
+            status: f.status,
+            run_as: f.run_as,
+            created: f.sys_created_on,
+            updated: f.sys_updated_on
+          };
+        });
+
+        var listSummary = summary()
+          .success('Found ' + flows.length + ' flow' + (flows.length === 1 ? '' : 's'));
+
+        for (var li = 0; li < Math.min(flows.length, 15); li++) {
+          var lf = flows[li];
+          listSummary.bullet(
+            lf.name +
+            ' [' + (lf.type || 'flow') + ']' +
+            (lf.active ? '' : ' (inactive)')
+          );
+        }
+        if (flows.length > 15) {
+          listSummary.indented('... and ' + (flows.length - 15) + ' more');
+        }
+
+        return createSuccessResult({
+          action: 'list',
+          count: flows.length,
+          flows: flows
+        }, {}, listSummary.build());
+      }
+
+      // ────────────────────────────────────────────────────────────────
+      // GET
+      // ────────────────────────────────────────────────────────────────
+      case 'get': {
+        if (!args.flow_id) {
+          throw new SnowFlowError(ErrorType.VALIDATION_ERROR, 'flow_id is required for get action');
+        }
+
+        var getSysId = await resolveFlowId(client, args.flow_id);
+
+        // Fetch flow record
+        var getResp = await client.get('/api/now/table/sys_hub_flow/' + getSysId);
+        var flowRecord = getResp.data.result;
+
+        // Fetch trigger instances
+        var triggerInstances: any[] = [];
+        try {
+          var trigResp = await client.get('/api/now/table/sys_hub_trigger_instance', {
+            params: {
+              sysparm_query: 'flow=' + getSysId,
+              sysparm_fields: 'sys_id,name,action_type,table,condition,active,order',
+              sysparm_limit: 10
+            }
+          });
+          triggerInstances = trigResp.data.result || [];
+        } catch (e) { /* best-effort */ }
+
+        // Fetch action instances
+        var actionInstances: any[] = [];
+        try {
+          var actResp = await client.get('/api/now/table/sys_hub_action_instance', {
+            params: {
+              sysparm_query: 'flow=' + getSysId + '^ORDERBYorder',
+              sysparm_fields: 'sys_id,name,action_type,order,active',
+              sysparm_limit: 50
+            }
+          });
+          actionInstances = actResp.data.result || [];
+        } catch (e) { /* best-effort */ }
+
+        // Fetch flow variables
+        var flowVars: any[] = [];
+        try {
+          var varResp = await client.get('/api/now/table/sys_hub_flow_variable', {
+            params: {
+              sysparm_query: 'flow=' + getSysId,
+              sysparm_fields: 'sys_id,name,label,type,mandatory,variable_type,default_value',
+              sysparm_limit: 50
+            }
+          });
+          flowVars = varResp.data.result || [];
+        } catch (e) { /* best-effort */ }
+
+        // Fetch recent executions
+        var executions: any[] = [];
+        try {
+          var execResp = await client.get('/api/now/table/sys_hub_flow_run', {
+            params: {
+              sysparm_query: 'flow=' + getSysId + '^ORDERBYDESCsys_created_on',
+              sysparm_fields: 'sys_id,state,started,ended,duration,trigger_record_table,trigger_record_id',
+              sysparm_limit: 10
+            }
+          });
+          executions = execResp.data.result || [];
+        } catch (e) { /* best-effort */ }
+
+        var getSummary = summary()
+          .success('Flow: ' + (flowRecord.name || args.flow_id))
+          .field('sys_id', flowRecord.sys_id)
+          .field('Type', flowRecord.type)
+          .field('Category', flowRecord.category)
+          .field('Status', flowRecord.active === 'true' ? 'Active' : 'Inactive')
+          .field('Run as', flowRecord.run_as)
+          .field('Description', flowRecord.description);
+
+        if (triggerInstances.length > 0) {
+          getSummary.blank().line('Triggers: ' + triggerInstances.length);
+          for (var ti = 0; ti < triggerInstances.length; ti++) {
+            getSummary.bullet(triggerInstances[ti].name || 'trigger-' + ti);
+          }
+        }
+        if (actionInstances.length > 0) {
+          getSummary.blank().line('Actions: ' + actionInstances.length);
+          for (var aci = 0; aci < Math.min(actionInstances.length, 10); aci++) {
+            getSummary.bullet(actionInstances[aci].name || 'action-' + aci);
+          }
+        }
+        if (flowVars.length > 0) {
+          getSummary.blank().line('Variables: ' + flowVars.length);
+        }
+        if (executions.length > 0) {
+          getSummary.blank().line('Recent executions: ' + executions.length);
+          for (var ei = 0; ei < Math.min(executions.length, 5); ei++) {
+            var ex = executions[ei];
+            getSummary.bullet((ex.state || 'unknown') + ' - ' + (ex.started || 'pending'));
+          }
+        }
+
+        return createSuccessResult({
+          action: 'get',
+          flow: {
+            sys_id: flowRecord.sys_id,
+            name: flowRecord.name,
+            description: flowRecord.description,
+            type: flowRecord.type,
+            category: flowRecord.category,
+            active: flowRecord.active === 'true',
+            status: flowRecord.status,
+            run_as: flowRecord.run_as,
+            created: flowRecord.sys_created_on,
+            updated: flowRecord.sys_updated_on
+          },
+          triggers: triggerInstances.map(function (t: any) {
+            return {
+              sys_id: t.sys_id,
+              name: t.name,
+              action_type: typeof t.action_type === 'object' ? t.action_type.display_value : t.action_type,
+              table: t.table,
+              condition: t.condition,
+              active: t.active === 'true'
+            };
+          }),
+          actions: actionInstances.map(function (a: any) {
+            return {
+              sys_id: a.sys_id,
+              name: a.name,
+              action_type: typeof a.action_type === 'object' ? a.action_type.display_value : a.action_type,
+              order: a.order,
+              active: a.active === 'true'
+            };
+          }),
+          variables: flowVars.map(function (v: any) {
+            return {
+              sys_id: v.sys_id,
+              name: v.name,
+              label: v.label,
+              type: v.type,
+              mandatory: v.mandatory === 'true',
+              variable_type: v.variable_type,
+              default_value: v.default_value
+            };
+          }),
+          recent_executions: executions.map(function (e: any) {
+            return {
+              sys_id: e.sys_id,
+              state: e.state,
+              started: e.started,
+              ended: e.ended,
+              duration: e.duration,
+              trigger_table: e.trigger_record_table,
+              trigger_record: e.trigger_record_id
+            };
+          })
+        }, {}, getSummary.build());
+      }
+
+      // ────────────────────────────────────────────────────────────────
+      // UPDATE
+      // ────────────────────────────────────────────────────────────────
+      case 'update': {
+        if (!args.flow_id) {
+          throw new SnowFlowError(ErrorType.VALIDATION_ERROR, 'flow_id is required for update action');
+        }
+        var updateFields = args.update_fields;
+        if (!updateFields || Object.keys(updateFields).length === 0) {
+          throw new SnowFlowError(ErrorType.VALIDATION_ERROR, 'update_fields is required for update action');
+        }
+
+        var updateSysId = await resolveFlowId(client, args.flow_id);
+        await client.patch('/api/now/table/sys_hub_flow/' + updateSysId, updateFields);
+
+        var updateSummary = summary()
+          .success('Updated flow: ' + args.flow_id)
+          .field('sys_id', updateSysId);
+
+        var fieldNames = Object.keys(updateFields);
+        for (var fi = 0; fi < fieldNames.length; fi++) {
+          updateSummary.field(fieldNames[fi], updateFields[fieldNames[fi]]);
+        }
+
+        return createSuccessResult({
+          action: 'update',
+          flow_id: updateSysId,
+          updated_fields: fieldNames,
+          message: 'Flow updated successfully'
+        }, {}, updateSummary.build());
+      }
+
+      // ────────────────────────────────────────────────────────────────
+      // ACTIVATE / PUBLISH
+      // ────────────────────────────────────────────────────────────────
+      case 'activate':
+      case 'publish': {
+        if (!args.flow_id) {
+          throw new SnowFlowError(ErrorType.VALIDATION_ERROR, 'flow_id is required for ' + action + ' action');
+        }
+
+        var activateSysId = await resolveFlowId(client, args.flow_id);
+        await client.patch('/api/now/table/sys_hub_flow/' + activateSysId, {
+          active: true,
+          status: 'published',
+          validated: true
+        });
+
+        var activateSummary = summary()
+          .success('Flow activated and published')
+          .field('sys_id', activateSysId);
+
+        return createSuccessResult({
+          action: action,
+          flow_id: activateSysId,
+          active: true,
+          status: 'published',
+          message: 'Flow activated and published'
+        }, {}, activateSummary.build());
+      }
+
+      // ────────────────────────────────────────────────────────────────
+      // DEACTIVATE
+      // ────────────────────────────────────────────────────────────────
+      case 'deactivate': {
+        if (!args.flow_id) {
+          throw new SnowFlowError(ErrorType.VALIDATION_ERROR, 'flow_id is required for deactivate action');
+        }
+
+        var deactivateSysId = await resolveFlowId(client, args.flow_id);
+        await client.patch('/api/now/table/sys_hub_flow/' + deactivateSysId, {
+          active: false
+        });
+
+        var deactivateSummary = summary()
+          .success('Flow deactivated')
+          .field('sys_id', deactivateSysId);
+
+        return createSuccessResult({
+          action: 'deactivate',
+          flow_id: deactivateSysId,
+          active: false,
+          message: 'Flow deactivated'
+        }, {}, deactivateSummary.build());
+      }
+
+      // ────────────────────────────────────────────────────────────────
+      // DELETE
+      // ────────────────────────────────────────────────────────────────
+      case 'delete': {
+        if (!args.flow_id) {
+          throw new SnowFlowError(ErrorType.VALIDATION_ERROR, 'flow_id is required for delete action');
+        }
+
+        var deleteSysId = await resolveFlowId(client, args.flow_id);
+        await client.delete('/api/now/table/sys_hub_flow/' + deleteSysId);
+
+        var deleteSummary = summary()
+          .success('Flow deleted')
+          .field('sys_id', deleteSysId);
+
+        return createSuccessResult({
+          action: 'delete',
+          flow_id: deleteSysId,
+          message: 'Flow deleted'
+        }, {}, deleteSummary.build());
+      }
+
+      default:
+        throw new SnowFlowError(ErrorType.VALIDATION_ERROR, 'Unknown action: ' + action);
+    }
+
+  } catch (error: any) {
+    if (error instanceof SnowFlowError) {
+      return createErrorResult(error);
+    }
+    if (error.response?.status === 403) {
+      return createErrorResult(
+        'Permission denied (403): Your ServiceNow user lacks Flow Designer permissions. ' +
+        'Required roles: "flow_designer" or "admin". Contact your ServiceNow administrator.'
+      );
+    }
+    return createErrorResult(
+      new SnowFlowError(ErrorType.UNKNOWN_ERROR, error.message, { originalError: error })
+    );
+  }
+}
+
+export const version = '1.0.0';
+export const author = 'Snow-Flow Team';

package/src/servicenow/servicenow-mcp-unified/tools/workflow/snow_workflow_manage.ts

@@ -31,16 +31,12 @@ const LEGACY_WARNING = `
 ServiceNow Workflow (wf_workflow) is deprecated in favor of Flow Designer.
 Flow Designer provides a modern, visual interface for building automations.
 
-However, Flow Designer is NOT programmable via Snow-Flow at this time.
+Use snow_manage_flow to create and manage Flow Designer flows programmatically.
 
 RECOMMENDATIONS:
-1. For NEW automations → Consider building manually in Flow Designer
+1. For NEW automations → Use snow_manage_flow (action: create)
 2. For EXISTING workflows → This tool can manage legacy workflows
-3. Need Flow Designer specs? → Ask Snow-Flow to generate a Flow Designer
-   specification document with the required triggers, actions, and logic.
-
-To generate a Flow Designer specification, ask:
-"Generate a Flow Designer specification for [describe your automation]"
+3. For MIGRATION → Use snow_manage_flow to recreate workflows as flows
 `;
 
 export const toolDefinition: MCPToolDefinition = {