snow-flow-test 10.0.1-test.108 → 10.0.1-test.110

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "10.0.1-test.108",
+  "version": "10.0.1-test.110",
   "name": "snow-flow-test",
   "description": "Snow-Flow Test - ServiceNow Multi-Agent Development Framework",
   "license": "Elastic-2.0",

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

@@ -35,7 +35,6 @@ function isSysId(value: string): boolean {
 
 var FLOW_FACTORY_API_NAME = 'Snow-Flow Flow Factory';
 var FLOW_FACTORY_API_ID = 'flow_factory';
-var FLOW_FACTORY_NAMESPACE = 'x_snflw';
 var FLOW_FACTORY_CACHE_TTL = 300000; // 5 minutes
 
 var _flowFactoryCache: { apiSysId: string; namespace: string; timestamp: number } | null = null;
@@ -48,7 +47,14 @@ var _bootstrapPromise: Promise<{ namespace: string; apiSysId: string }> | null =
  */
 var FLOW_FACTORY_SCRIPT = [
   '(function process(/*RESTAPIRequest*/ request, /*RESTAPIResponse*/ response) {',
-  '  var body = request.body.data;',
+  '  var body;',
+  '  try { body = JSON.parse(request.body.dataString); }',
+  '  catch(e) { body = request.body.data; }',
+  '  if (!body || typeof body !== "object") {',
+  '    response.setStatus(400);',
+  '    response.setBody({ success: false, error: "Invalid request body: " + typeof body });',
+  '    return;',
+  '  }',
   '  var result = { success: false, steps: {} };',
   '',
   '  try {',
@@ -101,6 +107,9 @@ var FLOW_FACTORY_SCRIPT = [
   '      ver.setValue("version", "1.0");',
   '      ver.setValue("state", shouldActivate ? "published" : "draft");',
   '      ver.setValue("active", true);',
+  '      ver.setValue("compile_state", "compiled");',
+  '      ver.setValue("is_current", true);',
+  '      if (shouldActivate) ver.setValue("published_flow", flowSysId);',
   '      if (body.flow_definition) {',
   '        ver.setValue("flow_definition", typeof body.flow_definition === "string" ? body.flow_definition : JSON.stringify(body.flow_definition));',
   '      }',
@@ -229,12 +238,97 @@ var FLOW_FACTORY_SCRIPT = [
   '})(request, response);'
 ].join('\n');
 
+/**
+ * Probe the ServiceNow instance to discover the correct URL namespace for
+ * the Flow Factory Scripted REST API. Sends GET requests to candidate
+ * namespaces — a 405 (Method Not Allowed) or 401/403 confirms the namespace
+ * exists, while 404 means wrong namespace.
+ */
+async function probeFlowFactoryNamespace(
+  client: any,
+  apiSysId: string,
+  instanceUrl: string
+): Promise<string | null> {
+  // Build candidate list from multiple sources
+  var candidates: string[] = [];
+
+  // 1. Read back the record's namespace field
+  try {
+    var nsResp = await client.get('/api/now/table/sys_ws_definition/' + apiSysId, {
+      params: { sysparm_fields: 'sys_id,api_id,namespace', sysparm_display_value: 'all' }
+    });
+    var record = nsResp.data.result || {};
+    var ns = record.namespace;
+    if (ns) {
+      if (typeof ns === 'object') {
+        var dv = ns.display_value || '';
+        var val = ns.value || '';
+        if (dv && /^(x_|sn_)/.test(dv)) candidates.push(dv);
+        if (val && /^(x_|sn_)/.test(val)) candidates.push(val);
+      } else if (typeof ns === 'string' && ns.length > 0 && ns !== 'Global' && ns !== 'global') {
+        candidates.push(ns);
+      }
+    }
+  } catch (_) {}
+
+  // 2. Company code from sys_properties
+  try {
+    var compResp = await client.get('/api/now/table/sys_properties', {
+      params: {
+        sysparm_query: 'name=glide.appcreator.company.code',
+        sysparm_fields: 'value',
+        sysparm_limit: 1
+      }
+    });
+    var companyCode = compResp.data.result?.[0]?.value;
+    if (companyCode) candidates.push(companyCode);
+  } catch (_) {}
+
+  // 3. Instance subdomain (e.g. "dev351277" from "https://dev351277.service-now.com")
+  try {
+    var match = instanceUrl.match(/https?:\/\/([^.]+)\./);
+    if (match && match[1]) candidates.push(match[1]);
+  } catch (_) {}
+
+  // 4. Fixed fallbacks
+  candidates.push('now', 'global');
+
+  // Deduplicate
+  var seen: Record<string, boolean> = {};
+  var unique: string[] = [];
+  for (var i = 0; i < candidates.length; i++) {
+    if (!seen[candidates[i]]) {
+      seen[candidates[i]] = true;
+      unique.push(candidates[i]);
+    }
+  }
+
+  // 5. Probe each candidate — GET on a POST-only endpoint
+  for (var j = 0; j < unique.length; j++) {
+    try {
+      await client.get('/api/' + unique[j] + '/' + FLOW_FACTORY_API_ID + '/create');
+      return unique[j]; // 200 = endpoint exists (unlikely but valid)
+    } catch (probeError: any) {
+      var status = probeError.response?.status;
+      if (status === 405 || status === 401 || status === 403) {
+        return unique[j]; // Namespace correct — method or auth rejected
+      }
+      // 404 = wrong namespace, try next
+    }
+  }
+
+  return null; // No namespace matched — factory unreachable
+}
+
 /**
  * Ensure the Flow Factory Scripted REST API exists on the ServiceNow instance.
  * Idempotent — checks cache first, then instance, deploys only if missing.
- * Uses a concurrency lock to prevent duplicate bootstrap calls.
+ * Uses namespace probing (HTTP GET) instead of record field parsing.
  */
-async function ensureFlowFactoryAPI(client: any): Promise<{ namespace: string; apiSysId: string }> {
+async function ensureFlowFactoryAPI(
+  client: any,
+  instanceUrl: string
+): Promise<{ namespace: string; apiSysId: string }> {
   // 1. Check in-memory cache
   if (_flowFactoryCache && (Date.now() - _flowFactoryCache.timestamp) < FLOW_FACTORY_CACHE_TTL) {
     return { namespace: _flowFactoryCache.namespace, apiSysId: _flowFactoryCache.apiSysId };
@@ -247,32 +341,34 @@ async function ensureFlowFactoryAPI(client: any): Promise<{ namespace: string; a
 
   _bootstrapPromise = (async () => {
     try {
-      // 3. Check if API already exists on instance
+      // 3. Check if API already exists on instance (query by api_id, more reliable than name)
       var checkResp = await client.get('/api/now/table/sys_ws_definition', {
         params: {
-          sysparm_query: 'name=' + FLOW_FACTORY_API_NAME,
-          sysparm_fields: 'sys_id,namespace.name',
+          sysparm_query: 'api_id=' + FLOW_FACTORY_API_ID,
+          sysparm_fields: 'sys_id,api_id,namespace',
           sysparm_limit: 1
         }
       });
 
       if (checkResp.data.result && checkResp.data.result.length > 0) {
         var existing = checkResp.data.result[0];
-        var ns = (existing['namespace.name'] || existing.namespace?.display_value || FLOW_FACTORY_NAMESPACE);
+        var ns = await probeFlowFactoryNamespace(client, existing.sys_id, instanceUrl);
+        if (!ns) {
+          throw new Error('Flow Factory API exists (sys_id=' + existing.sys_id + ') but namespace could not be resolved via HTTP probing');
+        }
         _flowFactoryCache = { apiSysId: existing.sys_id, namespace: ns, timestamp: Date.now() };
         return { namespace: ns, apiSysId: existing.sys_id };
       }
 
-      // 4. Deploy the Scripted REST API
+      // 4. Deploy the Scripted REST API (do NOT set namespace — let ServiceNow assign it)
       var apiResp = await client.post('/api/now/table/sys_ws_definition', {
         name: FLOW_FACTORY_API_NAME,
         api_id: FLOW_FACTORY_API_ID,
         active: true,
         short_description: 'Bootstrapped by Snow-Flow MCP for reliable Flow Designer creation via GlideRecord',
         is_versioned: false,
-        enforce_acl: 'no',
-        requires_authentication: true,
-        namespace: FLOW_FACTORY_NAMESPACE
+        enforce_acl: 'false',
+        requires_authentication: true
       });
 
       var apiSysId = apiResp.data.result?.sys_id;
@@ -291,7 +387,7 @@ async function ensureFlowFactoryAPI(client: any): Promise<{ namespace: string; a
           short_description: 'Create a flow or subflow with GlideRecord (triggers all BRs + version record)',
           operation_script: FLOW_FACTORY_SCRIPT,
           requires_authentication: true,
-          enforce_acl: 'no'
+          enforce_acl: 'false'
         });
       } catch (opError: any) {
         // Cleanup the API definition if operation creation fails
@@ -299,18 +395,10 @@ async function ensureFlowFactoryAPI(client: any): Promise<{ namespace: string; a
         throw new Error('Failed to create Scripted REST operation: ' + (opError.message || opError));
       }
 
-      // Resolve actual namespace — may differ from requested
-      var nsResp = await client.get('/api/now/table/sys_ws_definition/' + apiSysId, {
-        params: { sysparm_fields: 'sys_id,namespace' }
-      });
-      var resolvedNs = FLOW_FACTORY_NAMESPACE;
-      if (nsResp.data.result?.namespace) {
-        var nsVal = nsResp.data.result.namespace;
-        if (typeof nsVal === 'object' && nsVal.display_value) {
-          resolvedNs = nsVal.display_value;
-        } else if (typeof nsVal === 'string' && nsVal.length > 0) {
-          resolvedNs = nsVal;
-        }
+      // 6. Probe to discover the namespace ServiceNow assigned
+      var resolvedNs = await probeFlowFactoryNamespace(client, apiSysId, instanceUrl);
+      if (!resolvedNs) {
+        throw new Error('Flow Factory API created (sys_id=' + apiSysId + ') but namespace could not be resolved via HTTP probing');
       }
 
       _flowFactoryCache = { apiSysId: apiSysId, namespace: resolvedNs, timestamp: Date.now() };
@@ -578,8 +666,23 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
         var actionsCreated = 0;
         var varsCreated = 0;
 
+        // Diagnostics: track every step for debugging "flow cannot be found" issues
+        var diagnostics: any = {
+          factory_bootstrap: null,
+          factory_namespace: null,
+          factory_call: null,
+          table_api_used: false,
+          version_created: false,
+          version_method: null,
+          version_fields_set: [] as string[],
+          snapshot_result: null,
+          post_verify: null
+        };
+
         try {
-          var factory = await ensureFlowFactoryAPI(client);
+          var factory = await ensureFlowFactoryAPI(client, context.instanceUrl);
+          diagnostics.factory_bootstrap = 'success';
+          diagnostics.factory_namespace = factory.namespace;
 
           var factoryPayload = {
             name: flowName,
@@ -608,7 +711,8 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
             // 404 = API was deleted externally → invalidate cache, retry once
             if (callError.response?.status === 404) {
               invalidateFlowFactoryCache();
-              var retryFactory = await ensureFlowFactoryAPI(client);
+              var retryFactory = await ensureFlowFactoryAPI(client, context.instanceUrl);
+              diagnostics.factory_namespace = retryFactory.namespace;
               var retryEndpoint = '/api/' + retryFactory.namespace + '/' + FLOW_FACTORY_API_ID + '/create';
               factoryResp = await client.post(retryEndpoint, factoryPayload);
             } else {
@@ -618,9 +722,13 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
 
           var factoryResult = factoryResp.data?.result || factoryResp.data;
           if (factoryResult && factoryResult.success && factoryResult.flow_sys_id) {
+            diagnostics.factory_call = 'success';
             flowSysId = factoryResult.flow_sys_id;
             usedMethod = 'scripted_rest_api';
             versionCreated = !!factoryResult.version_created;
+            diagnostics.version_created = versionCreated;
+            diagnostics.version_method = 'factory';
+            diagnostics.version_fields_set = ['flow', 'name', 'version', 'state', 'active', 'compile_state', 'is_current', 'published_flow'];
 
             // Extract step details
             var steps = factoryResult.steps || {};
@@ -643,14 +751,19 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
         } catch (factoryError: any) {
           // Flow Factory unavailable — fall through to Table API
           var statusCode = factoryError.response?.status;
+          var factoryErrMsg = statusCode
+            ? 'HTTP ' + statusCode + ': ' + (factoryError.response?.data?.error?.message || factoryError.message || 'unknown')
+            : (factoryError.message || 'unknown');
+          diagnostics.factory_bootstrap = diagnostics.factory_bootstrap || ('error: ' + factoryErrMsg);
+          diagnostics.factory_call = diagnostics.factory_call || ('error: ' + factoryErrMsg);
           if (statusCode !== 403) {
-            // Log non-permission errors as warnings (403 = silently skip)
-            factoryWarnings.push('Flow Factory unavailable (' + (statusCode || factoryError.message || 'unknown') + '), using Table API fallback');
+            factoryWarnings.push('Flow Factory unavailable (' + factoryErrMsg + '), using Table API fallback');
           }
         }
 
         // ── Table API fallback (existing logic) ─────────────────────
         if (!flowSysId) {
+          diagnostics.table_api_used = true;
           var flowData: any = {
             name: flowName,
             description: flowDescription,
@@ -669,6 +782,40 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
           var createdFlow = flowResponse.data.result;
           flowSysId = createdFlow.sys_id;
 
+          // Create sys_hub_flow_version via Table API (critical for Flow Designer UI)
+          try {
+            var versionData: any = {
+              flow: flowSysId,
+              name: '1.0',
+              version: '1.0',
+              state: shouldActivate ? 'published' : 'draft',
+              active: true,
+              compile_state: 'compiled',
+              is_current: true,
+              flow_definition: JSON.stringify(flowDefinition)
+            };
+            if (shouldActivate) versionData.published_flow = flowSysId;
+            var versionResp = await client.post('/api/now/table/sys_hub_flow_version', versionData);
+            var versionSysId = versionResp.data.result?.sys_id;
+            if (versionSysId) {
+              versionCreated = true;
+              diagnostics.version_created = true;
+              diagnostics.version_method = 'table_api';
+              diagnostics.version_fields_set = ['flow', 'name', 'version', 'state', 'active', 'compile_state', 'is_current', 'published_flow'];
+              // Link flow to its version
+              try {
+                await client.patch('/api/now/table/sys_hub_flow/' + flowSysId, {
+                  latest_version: versionSysId
+                });
+              } catch (linkError) {
+                // Version exists but link failed — still better than no version
+                factoryWarnings.push('Version created but latest_version link failed');
+              }
+            }
+          } catch (verError: any) {
+            factoryWarnings.push('sys_hub_flow_version creation failed: ' + (verError.message || verError));
+          }
+
           // Create trigger instance (non-manual flows only)
           if (!isSubflow && triggerType !== 'manual') {
             try {
@@ -775,7 +922,77 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
           // Best-effort snapshot
           try {
             await client.post('/api/sn_flow_designer/flow/snapshot', { flow_id: flowSysId });
-          } catch (snapError) { /* may not exist */ }
+            diagnostics.snapshot_result = 'success';
+          } catch (snapError: any) {
+            diagnostics.snapshot_result = 'error: ' + (snapError.response?.status || snapError.message || 'unknown');
+          }
+        }
+
+        // ── Post-creation verification ─────────────────────────────
+        if (flowSysId) {
+          try {
+            var verifyResp = await client.get('/api/now/table/sys_hub_flow/' + flowSysId, {
+              params: { sysparm_fields: 'sys_id,name,latest_version' }
+            });
+            var verifyFlow = verifyResp.data.result;
+            var hasLatestVersion = !!(verifyFlow && verifyFlow.latest_version);
+
+            // Check if version record exists
+            var verCheckResp = await client.get('/api/now/table/sys_hub_flow_version', {
+              params: {
+                sysparm_query: 'flow=' + flowSysId,
+                sysparm_fields: 'sys_id,name,state,compile_state,is_current',
+                sysparm_limit: 1
+              }
+            });
+            var verRecords = verCheckResp.data.result || [];
+            var hasVersionRecord = verRecords.length > 0;
+
+            diagnostics.post_verify = {
+              flow_exists: true,
+              has_latest_version_ref: hasLatestVersion,
+              version_record_exists: hasVersionRecord,
+              version_details: hasVersionRecord ? {
+                sys_id: verRecords[0].sys_id,
+                state: verRecords[0].state,
+                compile_state: verRecords[0].compile_state,
+                is_current: verRecords[0].is_current
+              } : null
+            };
+
+            // If version record is missing, retry creation
+            if (!hasVersionRecord && !versionCreated) {
+              try {
+                var retryVersionData: any = {
+                  flow: flowSysId,
+                  name: '1.0',
+                  version: '1.0',
+                  state: shouldActivate ? 'published' : 'draft',
+                  active: true,
+                  compile_state: 'compiled',
+                  is_current: true,
+                  flow_definition: JSON.stringify(flowDefinition)
+                };
+                if (shouldActivate) retryVersionData.published_flow = flowSysId;
+
+                var retryVerResp = await client.post('/api/now/table/sys_hub_flow_version', retryVersionData);
+                var retryVerSysId = retryVerResp.data.result?.sys_id;
+                if (retryVerSysId) {
+                  versionCreated = true;
+                  diagnostics.version_created = true;
+                  diagnostics.version_method = (diagnostics.version_method || 'table_api') + ' (retry)';
+                  try {
+                    await client.patch('/api/now/table/sys_hub_flow/' + flowSysId, { latest_version: retryVerSysId });
+                  } catch (_) {}
+                  factoryWarnings.push('Version record was missing — created via post-verify retry');
+                }
+              } catch (retryErr: any) {
+                factoryWarnings.push('Post-verify version retry failed: ' + (retryErr.message || retryErr));
+              }
+            }
+          } catch (verifyErr: any) {
+            diagnostics.post_verify = { error: verifyErr.message || 'verification failed' };
+          }
         }
 
         // ── Build summary ───────────────────────────────────────────
@@ -791,8 +1008,14 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
           .field('Status', shouldActivate ? 'Published (active)' : 'Draft')
           .field('Method', methodLabel);
 
+        if (diagnostics.factory_namespace) {
+          createSummary.field('Namespace', diagnostics.factory_namespace);
+        }
+
         if (versionCreated) {
-          createSummary.field('Version', 'v1.0 created');
+          createSummary.field('Version', 'v1.0 created' + (diagnostics.version_method ? ' (' + diagnostics.version_method + ')' : ''));
+        } else {
+          createSummary.warning('Version record NOT created — flow may show "cannot be found" in Flow Designer');
         }
 
         if (!isSubflow && triggerType !== 'manual') {
@@ -809,6 +1032,24 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
           createSummary.warning(factoryWarnings[wi]);
         }
 
+        // Diagnostics section
+        createSummary.blank().line('Diagnostics:');
+        createSummary.indented('Factory bootstrap: ' + (diagnostics.factory_bootstrap || 'not attempted'));
+        createSummary.indented('Factory namespace: ' + (diagnostics.factory_namespace || 'n/a'));
+        createSummary.indented('Factory call: ' + (diagnostics.factory_call || 'not attempted'));
+        createSummary.indented('Table API used: ' + diagnostics.table_api_used);
+        createSummary.indented('Version created: ' + diagnostics.version_created + (diagnostics.version_method ? ' (' + diagnostics.version_method + ')' : ''));
+        createSummary.indented('Snapshot: ' + (diagnostics.snapshot_result || 'n/a'));
+        if (diagnostics.post_verify) {
+          if (diagnostics.post_verify.error) {
+            createSummary.indented('Post-verify: error — ' + diagnostics.post_verify.error);
+          } else {
+            createSummary.indented('Post-verify: flow=' + diagnostics.post_verify.flow_exists +
+              ', version_record=' + diagnostics.post_verify.version_record_exists +
+              ', latest_version_ref=' + diagnostics.post_verify.has_latest_version_ref);
+          }
+        }
+
         return createSuccessResult({
           created: true,
           method: usedMethod,
@@ -830,7 +1071,8 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
           activities_created: actionsCreated,
           activities_requested: activitiesArg.length,
           variables_created: varsCreated,
-          warnings: factoryWarnings.length > 0 ? factoryWarnings : undefined
+          warnings: factoryWarnings.length > 0 ? factoryWarnings : undefined,
+          diagnostics: diagnostics
         }, {}, createSummary.build());
       }
 
@@ -1183,5 +1425,5 @@ export async function execute(args: any, context: ServiceNowContext): Promise<To
   }
 }
 
-export const version = '2.0.0';
+export const version = '3.0.0';
 export const author = 'Snow-Flow Team';