snow-flow 10.0.1-dev.404 → 10.0.1-dev.407

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "10.0.1-dev.404",
+  "version": "10.0.1-dev.407",
   "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

@@ -165,46 +165,81 @@ async function createFlowViaScheduledJob(
     "",
     // ── Trigger, action, variable creation (runs for any tier) ──
     "    if (flowSysId) {",
-    // Trigger — search broadly for trigger definition (internal_name varies per instance)
+    // Trigger — precise search with prefix matching + fallback without action_type
     "      if (!isSubflow && trigType !== 'manual') {",
     "        try {",
-    "          var trigSearchTerms = {",
-    "            'record_created': ['record_created', 'record_insert', 'created'],",
-    "            'record_updated': ['record_updated', 'record_update', 'updated'],",
-    "            'scheduled': ['scheduled', 'timer', 'schedule']",
-    "          };",
-    "          var terms = trigSearchTerms[trigType] || [trigType];",
-    "          var trigDef = null;",
     "          var trigDefId = null;",
+    "          var trigDefName = '';",
     "          var trigSearchLog = [];",
-    "          for (var ts = 0; ts < terms.length; ts++) {",
-    "            var tg = new GlideRecord('sys_hub_action_type_definition');",
-    "            tg.addQuery('internal_name', 'CONTAINS', terms[ts]);",
-    "            tg.addQuery('type', 'trigger');",
-    "            tg.setLimit(1); tg.query();",
-    "            if (tg.next()) { trigDef = tg; trigDefId = tg.getUniqueValue(); trigSearchLog.push(terms[ts] + ':found'); break; }",
-    "            trigSearchLog.push(terms[ts] + ':not_found');",
+    "",
+    // Search 1: exact prefix 'sn_fd.trigger.' (standard Flow Designer naming)
+    "          var exactNames = {",
+    "            'record_created': ['sn_fd.trigger.record_created', 'global.sn_fd.trigger.record_created'],",
+    "            'record_updated': ['sn_fd.trigger.record_updated', 'global.sn_fd.trigger.record_updated'],",
+    "            'scheduled': ['sn_fd.trigger.scheduled', 'global.sn_fd.trigger.scheduled']",
+    "          };",
+    "          var exactCandidates = exactNames[trigType] || [];",
+    "          for (var ec = 0; ec < exactCandidates.length; ec++) {",
+    "            var tgE = new GlideRecord('sys_hub_action_type_definition');",
+    "            tgE.addQuery('internal_name', exactCandidates[ec]);",
+    "            tgE.setLimit(1); tgE.query();",
+    "            if (tgE.next()) {",
+    "              trigDefId = tgE.getUniqueValue(); trigDefName = tgE.getValue('name');",
+    "              trigSearchLog.push('exact:' + exactCandidates[ec] + ':found');",
+    "              break;",
+    "            }",
+    "            trigSearchLog.push('exact:' + exactCandidates[ec] + ':not_found');",
     "          }",
+    "",
+    // Search 2: prefix STARTSWITH 'sn_fd.trigger' (catches variations)
     "          if (!trigDefId) {",
-    "            var tg2 = new GlideRecord('sys_hub_action_type_definition');",
-    "            tg2.addQuery('name', 'CONTAINS', trigType.replace('_', ' '));",
-    "            tg2.addQuery('type', 'trigger');",
-    "            tg2.setLimit(1); tg2.query();",
-    "            if (tg2.next()) { trigDef = tg2; trigDefId = tg2.getUniqueValue(); trigSearchLog.push('name_search:found'); }",
-    "            else { trigSearchLog.push('name_search:not_found'); }",
+    "            var tgP = new GlideRecord('sys_hub_action_type_definition');",
+    "            tgP.addQuery('internal_name', 'STARTSWITH', 'sn_fd.trigger');",
+    "            tgP.setLimit(10); tgP.query();",
+    "            var prefixMatches = [];",
+    "            while (tgP.next()) {",
+    "              prefixMatches.push(tgP.getValue('internal_name'));",
+    "              if (!trigDefId && (tgP.getValue('internal_name') + '').indexOf(trigType.replace('record_', '')) > -1) {",
+    "                trigDefId = tgP.getUniqueValue(); trigDefName = tgP.getValue('name');",
+    "              }",
+    "            }",
+    "            trigSearchLog.push('prefix_sn_fd.trigger:[' + prefixMatches.join(',') + ']');",
     "          }",
-    "          if (trigDefId) {",
-    "            var trigInst = new GlideRecord('sys_hub_trigger_instance');",
-    "            trigInst.initialize();",
-    "            trigInst.setValue('flow', flowSysId); trigInst.setValue('action_type', trigDefId);",
-    "            trigInst.setValue('name', trigType); trigInst.setValue('order', 0); trigInst.setValue('active', true);",
-    "            if (trigTable) trigInst.setValue('table', trigTable);",
-    "            if (trigCondition) trigInst.setValue('condition', trigCondition);",
-    "            var trigId = trigInst.insert();",
-    "            r.steps.trigger = { success: !!trigId, sys_id: trigId + '', def_name: trigDef.getValue('name'), search: trigSearchLog };",
-    "          } else {",
-    "            r.steps.trigger = { success: false, error: 'No trigger def found', search: trigSearchLog };",
+    "",
+    // Search 3: sys_hub_trigger_definition table
+    "          if (!trigDefId) {",
+    "            try {",
+    "              var tg3 = new GlideRecord('sys_hub_trigger_definition');",
+    "              if (tg3.isValid()) {",
+    "                tg3.addQuery('internal_name', 'CONTAINS', trigType);",
+    "                tg3.setLimit(5); tg3.query();",
+    "                while (tg3.next()) {",
+    "                  var t3n = tg3.getValue('internal_name') + '';",
+    "                  trigSearchLog.push('trigger_def:' + t3n);",
+    "                  if (!trigDefId) { trigDefId = tg3.getUniqueValue(); trigDefName = tg3.getValue('name'); }",
+    "                }",
+    "              } else { trigSearchLog.push('trigger_def_table:not_valid'); }",
+    "            } catch(e3) { trigSearchLog.push('trigger_def_table:' + e3); }",
     "          }",
+    "",
+    // Create trigger instance
+    "          var trigInst = new GlideRecord('sys_hub_trigger_instance');",
+    "          trigInst.initialize();",
+    "          trigInst.setValue('flow', flowSysId);",
+    "          trigInst.setValue('name', trigType);",
+    "          trigInst.setValue('order', 0);",
+    "          trigInst.setValue('active', true);",
+    "          if (trigDefId) trigInst.setValue('action_type', trigDefId);",
+    "          if (trigTable) trigInst.setValue('table', trigTable);",
+    "          if (trigCondition) trigInst.setValue('condition', trigCondition);",
+    "          var trigId = trigInst.insert();",
+    "          r.steps.trigger = {",
+    "            success: !!trigId,",
+    "            sys_id: trigId + '',",
+    "            def_found: !!trigDefId,",
+    "            def_name: trigDefName || 'none (created without action_type)',",
+    "            search: trigSearchLog",
+    "          };",
     "        } catch(te) { r.steps.trigger = { success: false, error: te.getMessage ? te.getMessage() : te + '' }; }",
     "      }",
     // Actions
@@ -245,11 +280,11 @@ async function createFlowViaScheduledJob(
     "      }",
     "      r.steps.variables = { success: true, created: varsCreated };",
     "",
-    // ── Engine probe (discovery only — do NOT call publish/compile) ──
-    // Previous versions called FlowAPI.publish() which caused StackOverflowError
-    // and corrupted the flow. Now we only probe which APIs exist for diagnostics.
-    // The flow is left as a clean draft; user publishes via Flow Designer UI.
-    "      r.steps.engine = { apis_found: [], mode: 'probe_only' };",
+    // ── Engine: probe APIs + try compile (NOT publish — that StackOverflowed) ──
+    // FlowAPI.publish() caused StackOverflowError and corrupted the flow.
+    // FlowAPI.compile() should be safer — it registers the flow with the
+    // engine and sets latest_version without the publish side effects.
+    "      r.steps.engine = { apis_found: [], mode: 'probe_and_compile' };",
     "      try {",
     "        if (typeof sn_fd !== 'undefined') {",
     "          r.steps.engine.sn_fd = 'available';",
@@ -268,6 +303,24 @@ async function createFlowViaScheduledJob(
     "              }",
     "            } catch(e) {}",
     "          }",
+    // Try compile (safe) — DO NOT try publish (StackOverflowError)
+    "          var compiled = false;",
+    // Priority 1: FlowDesigner.compileFlow (most specific)
+    "          if (!compiled && sn_fd.FlowDesigner && typeof sn_fd.FlowDesigner.compileFlow === 'function') {",
+    "            try { sn_fd.FlowDesigner.compileFlow(flowSysId); r.steps.engine.compile = 'FlowDesigner.compileFlow:success'; compiled = true; }",
+    "            catch(e) { r.steps.engine.compile = 'FlowDesigner.compileFlow:' + (e.getMessage ? e.getMessage() : e + ''); }",
+    "          }",
+    // Priority 2: FlowCompiler.compile
+    "          if (!compiled && sn_fd.FlowCompiler && typeof sn_fd.FlowCompiler.compile === 'function') {",
+    "            try { sn_fd.FlowCompiler.compile(flowSysId); r.steps.engine.compile = 'FlowCompiler.compile:success'; compiled = true; }",
+    "            catch(e) { r.steps.engine.compile = 'FlowCompiler.compile:' + (e.getMessage ? e.getMessage() : e + ''); }",
+    "          }",
+    // Priority 3: FlowAPI.compile (available on this instance per diagnostics)
+    "          if (!compiled && sn_fd.FlowAPI && typeof sn_fd.FlowAPI.compile === 'function') {",
+    "            try { sn_fd.FlowAPI.compile(flowSysId); r.steps.engine.compile = 'FlowAPI.compile:success'; compiled = true; }",
+    "            catch(e) { r.steps.engine.compile = 'FlowAPI.compile:' + (e.getMessage ? e.getMessage() : e + ''); }",
+    "          }",
+    "          r.steps.engine.compiled = compiled;",
     "        } else {",
     "          r.steps.engine.sn_fd = 'unavailable';",
     "        }",
@@ -1476,54 +1529,59 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
           }
 
           // Create trigger instance (non-manual flows only)
-          // Search broadly — internal_name varies across ServiceNow instances
+          // Use precise prefix search, then fallback to creating without action_type
           if (!isSubflow && triggerType !== 'manual') {
             try {
-              var trigSearchTerms: Record<string, string[]> = {
-                'record_created': ['record_created', 'record_insert', 'created'],
-                'record_updated': ['record_updated', 'record_update', 'updated'],
-                'scheduled': ['scheduled', 'timer', 'schedule']
-              };
-              var searchTerms = trigSearchTerms[triggerType] || [triggerType];
               var triggerDefId: string | null = null;
 
-              for (var tsi = 0; tsi < searchTerms.length && !triggerDefId; tsi++) {
-                var triggerDefResp = await client.get('/api/now/table/sys_hub_action_type_definition', {
+              // Search 1: exact sn_fd.trigger.* prefix
+              var exactTrigNames: Record<string, string[]> = {
+                'record_created': ['sn_fd.trigger.record_created', 'global.sn_fd.trigger.record_created'],
+                'record_updated': ['sn_fd.trigger.record_updated', 'global.sn_fd.trigger.record_updated'],
+                'scheduled': ['sn_fd.trigger.scheduled', 'global.sn_fd.trigger.scheduled']
+              };
+              var exactCands = exactTrigNames[triggerType] || [];
+              for (var eci = 0; eci < exactCands.length && !triggerDefId; eci++) {
+                var exactResp = await client.get('/api/now/table/sys_hub_action_type_definition', {
                   params: {
-                    sysparm_query: 'internal_nameLIKE' + searchTerms[tsi] + '^type=trigger',
+                    sysparm_query: 'internal_name=' + exactCands[eci],
                     sysparm_fields: 'sys_id',
                     sysparm_limit: 1
                   }
                 });
-                triggerDefId = triggerDefResp.data.result?.[0]?.sys_id || null;
+                triggerDefId = exactResp.data.result?.[0]?.sys_id || null;
               }
 
-              // Fallback: search by display name
+              // Search 2: STARTSWITH sn_fd.trigger
               if (!triggerDefId) {
-                var trigNameResp = await client.get('/api/now/table/sys_hub_action_type_definition', {
+                var prefixResp = await client.get('/api/now/table/sys_hub_action_type_definition', {
                   params: {
-                    sysparm_query: 'nameLIKE' + triggerType.replace(/_/g, ' ') + '^type=trigger',
-                    sysparm_fields: 'sys_id',
-                    sysparm_limit: 1
+                    sysparm_query: 'internal_nameSTARTSWITHsn_fd.trigger',
+                    sysparm_fields: 'sys_id,internal_name',
+                    sysparm_limit: 10
                   }
                 });
-                triggerDefId = trigNameResp.data.result?.[0]?.sys_id || null;
+                var prefixResults = prefixResp.data.result || [];
+                for (var pri = 0; pri < prefixResults.length && !triggerDefId; pri++) {
+                  if ((prefixResults[pri].internal_name || '').indexOf(triggerType.replace('record_', '')) > -1) {
+                    triggerDefId = prefixResults[pri].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;
-              }
+              // Create trigger instance (with or without action_type)
+              var triggerData: any = {
+                flow: flowSysId,
+                name: triggerType,
+                order: 0,
+                active: true
+              };
+              if (triggerDefId) triggerData.action_type = triggerDefId;
+              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) {
               // Best-effort
             }