snow-flow 10.0.1-dev.409 → 10.0.1-dev.411

package/package.json

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

@@ -280,37 +280,70 @@ async function createFlowViaScheduledJob(
     "      }",
     "      r.steps.variables = { success: true, created: varsCreated };",
     "",
-    // ── Engine: PROBE ONLY — do NOT call compile or publish ──
-    // FlowAPI.publish() → StackOverflowError (corrupts flow)
-    // FlowAPI.compile() → "success" but doesn't set latest_version, may corrupt
-    // Just probe what APIs exist for diagnostics.
-    "      r.steps.engine = { apis_found: [], mode: 'probe_only' };",
+    // ── Reference: query an existing published flow to see what it looks like ──
+    "      r.steps.reference_flow = null;",
+    "      try {",
+    "        var refGr = new GlideRecord('sys_hub_flow');",
+    "        refGr.addQuery('status', 'published');",
+    "        refGr.addQuery('active', true);",
+    "        refGr.setLimit(1); refGr.query();",
+    "        if (refGr.next()) {",
+    "          var refId = refGr.getUniqueValue();",
+    "          var refFd = refGr.getValue('flow_definition') + '';",
+    "          var refLs = refGr.getValue('latest_snapshot') + '';",
+    "          var refLv = refGr.getValue('latest_version') + '';",
+    "          r.steps.reference_flow = {",
+    "            sys_id: refId,",
+    "            name: refGr.getValue('name'),",
+    "            has_flow_definition: refFd !== 'null' && refFd.length > 0,",
+    "            flow_definition_length: refFd.length,",
+    "            flow_definition_prefix: refFd.substring(0, 200),",
+    "            has_latest_snapshot: refLs !== 'null' && refLs.length > 0,",
+    "            latest_snapshot_length: refLs.length,",
+    "            latest_version: refLv,",
+    "            has_latest_version: refLv !== 'null' && refLv.length > 5",
+    "          };",
+    // Also read the version record of the reference flow
+    "          if (refLv !== 'null' && refLv.length > 5) {",
+    "            var refVer = new GlideRecord('sys_hub_flow_version');",
+    "            if (refVer.get(refLv)) {",
+    "              var refVFd = refVer.getValue('flow_definition') + '';",
+    "              r.steps.reference_flow.version_state = refVer.getValue('state');",
+    "              r.steps.reference_flow.version_compile_state = refVer.getValue('compile_state');",
+    "              r.steps.reference_flow.version_is_current = refVer.getValue('is_current');",
+    "              r.steps.reference_flow.version_active = refVer.getValue('active');",
+    "              r.steps.reference_flow.version_has_flow_def = refVFd !== 'null' && refVFd.length > 0;",
+    "              r.steps.reference_flow.version_flow_def_length = refVFd.length;",
+    "              r.steps.reference_flow.version_flow_def_prefix = refVFd.substring(0, 200);",
+    "            }",
+    "          }",
+    "        }",
+    "      } catch(refE) { r.steps.reference_flow = { error: refE + '' }; }",
+    "",
+    // ── Engine: try FlowAPI.compile() now that flow_definition is set ──
+    // DO NOT try publish (StackOverflowError). Only compile.
+    "      r.steps.engine = { apis_found: [], mode: 'compile_with_flowdef' };",
     "      try {",
     "        if (typeof sn_fd !== 'undefined') {",
     "          r.steps.engine.sn_fd = 'available';",
-    "          var probeNames = ['FlowDesigner', 'FlowCompiler', 'FlowAPI', 'FlowPublisher'];",
-    "          for (var pn = 0; pn < probeNames.length; pn++) {",
+    "          if (sn_fd.FlowAPI && typeof sn_fd.FlowAPI.compile === 'function') {",
+    "            r.steps.engine.apis_found.push('FlowAPI');",
     "            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) {}",
+    "              var compileResult = sn_fd.FlowAPI.compile(flowSysId);",
+    "              r.steps.engine.compile = 'success';",
+    "              r.steps.engine.compile_result = (compileResult + '').substring(0, 200);",
+    "            } catch(ce) {",
+    "              r.steps.engine.compile = 'error:' + (ce.getMessage ? ce.getMessage() : ce + '');",
+    "            }",
+    // Check latest_version immediately after compile
+    "            var postCompile = new GlideRecord('sys_hub_flow');",
+    "            if (postCompile.get(flowSysId)) {",
+    "              r.steps.engine.latest_version_after_compile = postCompile.getValue('latest_version') + '';",
+    "            }",
     "          }",
     "        } else {",
     "          r.steps.engine.sn_fd = 'unavailable';",
     "        }",
-    "        try {",
-    "          if (typeof GlideFlowDesigner !== 'undefined') {",
-    "            r.steps.engine.apis_found.push('GlideFlowDesigner');",
-    "          }",
-    "        } catch(e) {}",
     "      } catch(engineErr) {",
     "        r.steps.engine.error = engineErr.getMessage ? engineErr.getMessage() : engineErr + '';",
     "      }",
@@ -318,12 +351,17 @@ async function createFlowViaScheduledJob(
     "",
     "    r.flow_sys_id = flowSysId ? flowSysId + '' : null;",
     "    r.version_sys_id = verSysId ? verSysId + '' : null;",
-    // ── Post-engine check: re-read latest_version ──
+    // ── Final check: re-read latest_version + compare our flow to reference ──
     "    if (flowSysId) {",
     "      var cf = new GlideRecord('sys_hub_flow');",
     "      if (cf.get(flowSysId)) {",
     "        r.latest_version_set = !cf.latest_version.nil();",
     "        r.latest_version_value = cf.getValue('latest_version') + '';",
+    // Also read our flow_definition to verify it was stored
+    "        var ourFd = cf.getValue('flow_definition') + '';",
+    "        r.our_flow_definition_stored = ourFd !== 'null' && ourFd.length > 0;",
+    "        r.our_flow_definition_length = ourFd.length;",
+    "        r.our_flow_definition_prefix = ourFd.substring(0, 200);",
     "      }",
     "    }",
     "  } catch(e) { r.success = false; r.error = e.getMessage ? e.getMessage() : e + ''; }",
@@ -1634,11 +1672,11 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
 
         }
 
-        // ── Register flow with Flow Designer engine (Table API only) ──
-        // For scheduled job path, engine registration is done server-side
-        // inside the job script (via sn_fd APIs). Only call the external
-        // REST-based registration for the Table API fallback path.
-        if (flowSysId && usedMethod.startsWith('table_api')) {
+        // ── Register flow with Flow Designer engine ──
+        // Call the REST API (publish/activate/checkout+checkin/snapshot) to
+        // trigger engine compilation and set latest_version (computed field
+        // that cannot be set via GlideRecord or Table API PATCH).
+        if (flowSysId) {
           var engineResult = await registerFlowWithEngine(client, flowSysId, shouldActivate);
           diagnostics.engine_registration = {
             success: engineResult.success,