snow-flow 10.0.1-dev.403 → 10.0.1-dev.405

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "10.0.1-dev.403",
+  "version": "10.0.1-dev.405",
   "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,24 +165,79 @@ async function createFlowViaScheduledJob(
     "",
     // ── Trigger, action, variable creation (runs for any tier) ──
     "    if (flowSysId) {",
-    // Trigger
+    // Trigger — search broadly (no type filter, internal_name varies per instance)
     "      if (!isSubflow && trigType !== 'manual') {",
     "        try {",
-    "          var triggerMap = { 'record_created': 'sn_fd.trigger.record_created', 'record_updated': 'sn_fd.trigger.record_updated', 'scheduled': 'sn_fd.trigger.scheduled' };",
-    "          var trigIntName = triggerMap[trigType] || '';",
-    "          if (trigIntName) {",
-    "            var trigDef = new GlideRecord('sys_hub_action_type_definition');",
-    "            trigDef.addQuery('internal_name', trigIntName); trigDef.query();",
-    "            if (trigDef.next()) {",
-    "              var trigInst = new GlideRecord('sys_hub_trigger_instance');",
-    "              trigInst.initialize();",
-    "              trigInst.setValue('flow', flowSysId); trigInst.setValue('action_type', trigDef.getUniqueValue());",
-    "              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 + '' };",
-    "            } else { r.steps.trigger = { success: false, error: 'Trigger def not found: ' + trigIntName }; }",
+    "          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 trigSearchLog = [];",
+    // Search 1: CONTAINS on internal_name (NO type filter — 'type' column values vary)
+    "          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.setLimit(5); tg.query();",
+    "            while (tg.next()) {",
+    "              var tgType = tg.getValue('type') + '';",
+    "              var tgName = tg.getValue('internal_name') + '';",
+    "              trigSearchLog.push(terms[ts] + ':' + tgName + '(type=' + tgType + ')');",
+    "              if (!trigDefId) { trigDef = tg; trigDefId = tg.getUniqueValue(); }",
+    "            }",
+    "            if (trigDefId) break;",
+    "          }",
+    // Search 2: by display name (no type filter)
+    "          if (!trigDefId) {",
+    "            var tg2 = new GlideRecord('sys_hub_action_type_definition');",
+    "            tg2.addQuery('name', 'CONTAINS', trigType.replace('_', ' '));",
+    "            tg2.setLimit(5); tg2.query();",
+    "            while (tg2.next()) {",
+    "              var tg2Type = tg2.getValue('type') + '';",
+    "              var tg2Name = tg2.getValue('internal_name') + '';",
+    "              trigSearchLog.push('name:' + tg2Name + '(type=' + tg2Type + ')');",
+    "              if (!trigDefId) { trigDef = tg2; trigDefId = tg2.getUniqueValue(); }",
+    "            }",
+    "          }",
+    // Search 3: sys_hub_trigger_definition table (alternative on some instances)
+    "          if (!trigDefId) {",
+    "            try {",
+    "              var tg3 = new GlideRecord('sys_hub_trigger_definition');",
+    "              if (tg3.isValid()) {",
+    "                tg3.addQuery('internal_name', 'CONTAINS', terms[0]);",
+    "                tg3.setLimit(3); tg3.query();",
+    "                while (tg3.next()) {",
+    "                  trigSearchLog.push('trig_def_table:' + tg3.getValue('internal_name'));",
+    "                  if (!trigDefId) { trigDef = tg3; trigDefId = tg3.getUniqueValue(); }",
+    "                }",
+    "              } else { trigSearchLog.push('trig_def_table:invalid'); }",
+    "            } catch(e3) { trigSearchLog.push('trig_def_table:error'); }",
+    "          }",
+    // Discovery: log what type values exist (helps debug trigger issues)
+    "          if (!trigDefId) {",
+    "            try {",
+    "              var disc = new GlideAggregate('sys_hub_action_type_definition');",
+    "              disc.addAggregate('COUNT', 'type');",
+    "              disc.groupBy('type'); disc.query();",
+    "              var typeValues = [];",
+    "              while (disc.next()) { typeValues.push(disc.getValue('type') + ':' + disc.getAggregate('COUNT', 'type')); }",
+    "              trigSearchLog.push('type_values:[' + typeValues.join(',') + ']');",
+    "            } catch(de) { trigSearchLog.push('discovery:error'); }",
+    "          }",
+    "          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'), def_internal: trigDef.getValue('internal_name'), search: trigSearchLog };",
+    "          } else {",
+    "            r.steps.trigger = { success: false, error: 'No trigger def found after broad search', search: trigSearchLog };",
     "          }",
     "        } catch(te) { r.steps.trigger = { success: false, error: te.getMessage ? te.getMessage() : te + '' }; }",
     "      }",
@@ -224,40 +279,47 @@ async function createFlowViaScheduledJob(
     "      }",
     "      r.steps.variables = { success: true, created: varsCreated };",
     "",
-    // ── Engine registration (server-side sn_fd APIs) ──
-    "      r.steps.engine = { apis_found: [] };",
+    // ── 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';",
-    "          if (sn_fd.FlowDesigner) {",
-    "            r.steps.engine.apis_found.push('FlowDesigner');",
-    "            if (typeof sn_fd.FlowDesigner.publishFlow === 'function') {",
-    "              try {",
-    "                sn_fd.FlowDesigner.publishFlow(flowSysId);",
-    "                r.steps.engine.publish = 'success';",
-    "              } catch(pe) { r.steps.engine.publish = pe.getMessage ? pe.getMessage() : pe + ''; }",
-    "            }",
+    "          var probeNames = ['FlowDesigner', 'FlowCompiler', 'FlowAPI', 'FlowPublisher'];",
+    "          for (var pn = 0; pn < probeNames.length; pn++) {",
+    "            try {",
+    "              if (sn_fd[probeNames[pn]]) {",
+    "                r.steps.engine.apis_found.push(probeNames[pn]);",
+    "                var methods = [];",
+    "                var pObj = sn_fd[probeNames[pn]];",
+    "                var checkMethods = ['createFlow','publishFlow','activateFlow','compileFlow','compile','publish','getFlow'];",
+    "                for (var cm = 0; cm < checkMethods.length; cm++) {",
+    "                  if (typeof pObj[checkMethods[cm]] === 'function') methods.push(checkMethods[cm]);",
+    "                }",
+    "                if (methods.length > 0) r.steps.engine[probeNames[pn] + '_methods'] = methods;",
+    "              }",
+    "            } catch(e) {}",
     "          }",
-    "          if (sn_fd.FlowCompiler) {",
-    "            r.steps.engine.apis_found.push('FlowCompiler');",
-    "            if (typeof sn_fd.FlowCompiler.compile === 'function') {",
-    "              try {",
-    "                sn_fd.FlowCompiler.compile(flowSysId);",
-    "                r.steps.engine.compile = 'success';",
-    "              } catch(ce) { r.steps.engine.compile = ce.getMessage ? ce.getMessage() : ce + ''; }",
-    "            }",
+    // 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 + ''); }",
     "          }",
-    "          var otherApis = ['FlowAPI', 'FlowPublisher'];",
-    "          for (var oa = 0; oa < otherApis.length; oa++) {",
-    "            if (sn_fd[otherApis[oa]]) {",
-    "              r.steps.engine.apis_found.push(otherApis[oa]);",
-    "              var apiObj = sn_fd[otherApis[oa]];",
-    "              if (typeof apiObj.publish === 'function') {",
-    "                try { apiObj.publish(flowSysId); r.steps.engine[otherApis[oa] + '_publish'] = 'success'; }",
-    "                catch(e) { r.steps.engine[otherApis[oa] + '_publish'] = 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';",
     "        }",
@@ -1466,39 +1528,53 @@ 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
           if (!isSubflow && triggerType !== 'manual') {
             try {
-              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 trigSearchTerms: Record<string, string[]> = {
+                'record_created': ['record_created', 'record_insert', 'created'],
+                'record_updated': ['record_updated', 'record_update', 'updated'],
+                'scheduled': ['scheduled', 'timer', 'schedule']
               };
-              var triggerInternalName = triggerTypeLookup[triggerType] || '';
+              var searchTerms = trigSearchTerms[triggerType] || [triggerType];
+              var triggerDefId: string | null = null;
 
-              if (triggerInternalName) {
+              for (var tsi = 0; tsi < searchTerms.length && !triggerDefId; tsi++) {
                 var triggerDefResp = await client.get('/api/now/table/sys_hub_action_type_definition', {
                   params: {
-                    sysparm_query: 'internal_name=' + triggerInternalName,
+                    sysparm_query: 'internal_nameLIKE' + searchTerms[tsi] + '^type=trigger',
                     sysparm_fields: 'sys_id',
                     sysparm_limit: 1
                   }
                 });
+                triggerDefId = triggerDefResp.data.result?.[0]?.sys_id || null;
+              }
 
-                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;
-                }
+              // Fallback: search by display name
+              if (!triggerDefId) {
+                var trigNameResp = 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
+                  }
+                });
+                triggerDefId = trigNameResp.data.result?.[0]?.sys_id || null;
+              }
+
+              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) {
               // Best-effort