snow-flow 8.41.16 → 8.41.17

package/dist/mcp/servicenow-mcp-unified/tools/flow-designer/snow_manage_flow.js

@@ -77,11 +77,6 @@ const error_handler_js_1 = require("../../shared/error-handler.js");
 const crypto = __importStar(require("crypto"));
 const zlib = __importStar(require("zlib"));
 // ==================== CONSTANTS ====================
-/**
- * Compression header used by ServiceNow for V2 values fields
- * Note: ServiceNow may not use a header - values are just gzip + base64
- * We detect on read and write without header for compatibility
- */
 const COMPRESSED_HEADER = 'COMPRESSED:';
 /**
  * Flow Designer Table Structure
@@ -192,7 +187,31 @@ Features:
             },
             trigger: {
                 type: 'object',
-                description: '[create] Trigger configuration'
+                description: `[create] Trigger configuration. Use specific trigger types:
+- record_created: Triggers when a record is created on the specified table
+- record_updated: Triggers when a record is updated
+- record_deleted: Triggers when a record is deleted
+- record_created_or_updated: Triggers on both create and update
+- scheduled: Time-based trigger (requires schedule config)
+- api: REST API trigger
+- inbound_email: Email trigger
+- service_catalog: Catalog item trigger`,
+                properties: {
+                    type: {
+                        type: 'string',
+                        enum: ['record_created', 'record_updated', 'record_deleted', 'record_created_or_updated',
+                            'scheduled', 'api', 'inbound_email', 'service_catalog'],
+                        description: 'Trigger type - use record_created/record_updated instead of generic record'
+                    },
+                    table: {
+                        type: 'string',
+                        description: 'Table name for record triggers (e.g., incident, task, sys_user)'
+                    },
+                    condition: {
+                        type: 'string',
+                        description: 'Filter condition (encoded query) for when the trigger should fire'
+                    }
+                }
             },
             actions: {
                 type: 'array',
@@ -293,20 +312,17 @@ function generateInternalName(name, prefix = 'x_snfl') {
 }
 /**
  * Compress value for Xanadu+ versions
- * Uses gzip compression + base64 encoding
- *
- * ServiceNow stores values as: base64(gzip(JSON))
- * No header is used - the data starts directly with base64
+ * Uses gzip compression + base64 encoding with COMPRESSED: header
  */
-function compressValue(value, useHeader = false) {
+function compressValue(value) {
     const jsonStr = typeof value === 'object' ? JSON.stringify(value) : value;
     try {
         // Compress with gzip
         const compressed = zlib.gzipSync(Buffer.from(jsonStr, 'utf-8'));
         // Encode as base64
         const encoded = compressed.toString('base64');
-        // Return with or without header based on detection
-        return useHeader ? COMPRESSED_HEADER + encoded : encoded;
+        // Add header
+        return COMPRESSED_HEADER + encoded;
     }
     catch (error) {
         console.error('Compression failed, returning uncompressed:', error);
@@ -315,32 +331,19 @@ function compressValue(value, useHeader = false) {
 }
 /**
  * Decompress value from Xanadu+ format
- * Handles both with and without COMPRESSED: header
  */
 function decompressValue(value) {
-    if (!value) {
+    if (!value || !value.startsWith(COMPRESSED_HEADER)) {
         return value;
     }
     try {
-        let encoded = value;
-        // Check if it has the COMPRESSED: header
-        if (value.startsWith(COMPRESSED_HEADER)) {
-            encoded = value.substring(COMPRESSED_HEADER.length);
-        }
-        // Try to decode base64 and decompress
+        // Remove header
+        const encoded = value.substring(COMPRESSED_HEADER.length);
+        // Decode base64
         const compressed = Buffer.from(encoded, 'base64');
-        // Check if it's actually gzip compressed (magic bytes: 1f 8b)
-        if (compressed.length >= 2 && compressed[0] === 0x1f && compressed[1] === 0x8b) {
-            const decompressed = zlib.gunzipSync(compressed);
-            return decompressed.toString('utf-8');
-        }
-        // Not compressed, return original or try as plain base64
-        try {
-            return Buffer.from(encoded, 'base64').toString('utf-8');
-        }
-        catch {
-            return value;
-        }
+        // Decompress gzip
+        const decompressed = zlib.gunzipSync(compressed);
+        return decompressed.toString('utf-8');
     }
     catch (error) {
         console.error('Decompression failed:', error);
@@ -348,29 +351,9 @@ function decompressValue(value) {
     }
 }
 /**
- * Check if value is compressed (with or without header)
+ * Check if value is compressed
  */
 function isCompressed(value) {
-    if (!value)
-        return false;
-    // Check for COMPRESSED: header
-    if (value.startsWith(COMPRESSED_HEADER)) {
-        return true;
-    }
-    // Check if it looks like base64 encoded gzip data
-    try {
-        const decoded = Buffer.from(value, 'base64');
-        // Gzip magic bytes: 1f 8b
-        return decoded.length >= 2 && decoded[0] === 0x1f && decoded[1] === 0x8b;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Check if value uses the COMPRESSED: header format
- */
-function usesCompressionHeader(value) {
     return value && value.startsWith(COMPRESSED_HEADER);
 }
 /**
@@ -384,18 +367,15 @@ async function detectVersion(client) {
         });
         // Check if values are compressed by looking at a sample
         let useCompression = false;
-        let useCompressionHeader = false;
         if (v2Response.data.result && v2Response.data.result.length > 0) {
             const sample = v2Response.data.result[0];
-            if (sample.values) {
-                useCompression = isCompressed(sample.values);
-                useCompressionHeader = usesCompressionHeader(sample.values);
+            if (sample.values && isCompressed(sample.values)) {
+                useCompression = true;
             }
         }
         return {
             useV2Tables: true,
             useCompression,
-            useCompressionHeader,
             version: useCompression ? 'Xanadu+' : 'Washington DC+'
         };
     }
@@ -404,7 +384,6 @@ async function detectVersion(client) {
         return {
             useV2Tables: false,
             useCompression: false,
-            useCompressionHeader: false,
             version: 'Pre-Washington DC'
         };
     }
@@ -475,10 +454,10 @@ function buildGlideListValue(values) {
  * Build values JSON for action instance - ENHANCED VERSION
  * Supports: data pills, references, arrays, scripts, conditions, transforms
  */
-function buildActionValues(inputs, useCompression, useCompressionHeader = false) {
+function buildActionValues(inputs, useCompression) {
     if (!inputs || Object.keys(inputs).length === 0) {
         const emptyValue = '{}';
-        return useCompression ? compressValue(emptyValue, useCompressionHeader) : emptyValue;
+        return useCompression ? compressValue(emptyValue) : emptyValue;
     }
     const values = {};
     for (const [key, value] of Object.entries(inputs)) {
@@ -628,7 +607,7 @@ function buildActionValues(inputs, useCompression, useCompressionHeader = false)
         };
     }
     const jsonStr = JSON.stringify(values);
-    return useCompression ? compressValue(jsonStr, useCompressionHeader) : jsonStr;
+    return useCompression ? compressValue(jsonStr) : jsonStr;
 }
 /**
  * Remap sys_ids in values JSON when cloning
@@ -700,12 +679,11 @@ async function getTriggerTypeSysId(client, triggerType, when) {
         searchName = triggerMap[triggerType];
     }
     try {
-        // Note: sys_hub_trigger_type doesn't have 'label' or 'active' fields
         const response = await client.get('/api/now/table/sys_hub_trigger_type', {
             params: {
-                sysparm_query: `nameLIKE${searchName}`,
+                sysparm_query: `nameLIKE${searchName}^ORlabelLIKE${searchName}`,
                 sysparm_limit: 1,
-                sysparm_fields: 'sys_id,name,description'
+                sysparm_fields: 'sys_id,name,label'
             }
         });
         if (response.data.result && response.data.result.length > 0) {
@@ -725,17 +703,16 @@ async function getActionTypeSysId(client, actionType) {
         return { sys_id: actionType, name: actionType };
     }
     try {
-        // Note: sys_hub_action_type_base doesn't have 'label' or 'active' fields
         const response = await client.get('/api/now/table/sys_hub_action_type_base', {
             params: {
-                sysparm_query: `nameLIKE${actionType}`,
+                sysparm_query: `nameLIKE${actionType}^ORlabelLIKE${actionType}^active=true`,
                 sysparm_limit: 1,
-                sysparm_fields: 'sys_id,name,description'
+                sysparm_fields: 'sys_id,name,label'
             }
         });
         if (response.data.result && response.data.result.length > 0) {
             const result = response.data.result[0];
-            return { sys_id: result.sys_id, name: result.name };
+            return { sys_id: result.sys_id, name: result.name || result.label };
         }
     }
     catch (error) {
@@ -874,7 +851,13 @@ async function handleCreate(args, client, versionInfo) {
                 active: true,
                 order: 0
             };
-            if (triggerConfig.type === 'record') {
+            // Handle record triggers (both legacy 'record' type and new specific types)
+            const isRecordTrigger = triggerConfig.type === 'record' ||
+                triggerConfig.type === 'record_created' ||
+                triggerConfig.type === 'record_updated' ||
+                triggerConfig.type === 'record_deleted' ||
+                triggerConfig.type === 'record_created_or_updated';
+            if (isRecordTrigger) {
                 if (triggerConfig.table)
                     triggerData.table = triggerConfig.table;
                 if (triggerConfig.condition) {
@@ -912,10 +895,9 @@ async function handleCreate(args, client, versionInfo) {
             'reference': 'reference', 'object': 'object', 'array': 'array',
             'glide_date_time': 'glide_date_time'
         };
-        // Note: sys_hub_flow_variable uses 'model' field (not 'flow') to reference the parent flow
         const variableData = {
             sys_id: variableSysId,
-            model: flowSysId,
+            flow: flowSysId,
             name: variable.name,
             label: variable.label || variable.name,
             description: variable.description || '',
@@ -983,7 +965,7 @@ async function handleCreate(args, client, versionInfo) {
                             branch: 'then'
                         };
                         if (thenAction.inputs) {
-                            actionData.values = buildActionValues(thenAction.inputs, useCompression, versionInfo.useCompressionHeader);
+                            actionData.values = buildActionValues(thenAction.inputs, useCompression);
                         }
                         try {
                             await client.post(`/api/now/table/${actionTable}`, actionData);
@@ -1022,7 +1004,7 @@ async function handleCreate(args, client, versionInfo) {
                             branch: 'else'
                         };
                         if (elseAction.inputs) {
-                            actionData.values = buildActionValues(elseAction.inputs, useCompression, versionInfo.useCompressionHeader);
+                            actionData.values = buildActionValues(elseAction.inputs, useCompression);
                         }
                         try {
                             await client.post(`/api/now/table/${actionTable}`, actionData);
@@ -1096,7 +1078,7 @@ async function handleCreate(args, client, versionInfo) {
                             parent_logic_instance: loopSysId
                         };
                         if (loopAction.inputs) {
-                            actionData.values = buildActionValues(loopAction.inputs, useCompression, versionInfo.useCompressionHeader);
+                            actionData.values = buildActionValues(loopAction.inputs, useCompression);
                         }
                         try {
                             await client.post(`/api/now/table/${actionTable}`, actionData);
@@ -1144,7 +1126,7 @@ async function handleCreate(args, client, versionInfo) {
             active: true
         };
         if (actionConfig.inputs) {
-            actionData.values = buildActionValues(actionConfig.inputs, useCompression, versionInfo.useCompressionHeader);
+            actionData.values = buildActionValues(actionConfig.inputs, useCompression);
         }
         try {
             await client.post(`/api/now/table/${actionTable}`, actionData);
@@ -1156,65 +1138,21 @@ async function handleCreate(args, client, versionInfo) {
         }
         currentOrder += 100;
     }
-    // 7. CREATE SNAPSHOT WITH FLOW DEFINITION
-    // This is CRITICAL - Flow Designer requires snapshots with main_snapshot/latest_snapshot references
+    // 7. CREATE SNAPSHOT
     if (create_snapshot) {
-        console.log('Creating snapshot with flow definition...');
-        // Build the flow definition structure that Flow Designer expects
-        const flowDefinition = {
-            sys_id: flowSysId,
-            name: flowConfig.name,
-            internal_name: internalName,
-            description: flowConfig.description || '',
-            flow_type: 'flow',
-            run_as: flowConfig.run_as || 'system',
-            // Include references to created components
-            trigger: triggerConfig ? {
-                sys_id: triggerSysId,
-                type: triggerConfig.type,
-                table: triggerConfig.table,
-                when: triggerConfig.when
-            } : null,
-            actions: createdRecords
-                .filter(r => r.table === actionTable)
-                .map(r => ({ sys_id: r.sys_id, name: r.name })),
-            logic: createdRecords
-                .filter(r => r.table === logicTable)
-                .map(r => ({ sys_id: r.sys_id, name: r.name, type: r.type })),
-            variables: createdRecords
-                .filter(r => r.table === FLOW_TABLES.VARIABLE)
-                .map(r => ({ sys_id: r.sys_id, name: r.name }))
-        };
+        console.log('Creating snapshot...');
         const snapshotData = {
             sys_id: snapshotSysId,
             flow: flowSysId,
             name: `${flowConfig.name} - Initial`,
             version: '1.0.0',
             active: true,
-            published: false,
-            // Store the flow definition - this is what Flow Designer reads
-            definition: useCompression
-                ? compressValue(flowDefinition, versionInfo.useCompressionHeader)
-                : JSON.stringify(flowDefinition)
+            published: false
         };
         try {
             await client.post(`/api/now/table/${FLOW_TABLES.SNAPSHOT}`, snapshotData);
             createdRecords.push({ table: FLOW_TABLES.SNAPSHOT, sys_id: snapshotSysId, name: `${flowConfig.name} - Initial` });
             console.log(`✅ Created snapshot: ${snapshotSysId}`);
-            // *** CRITICAL FIX ***
-            // Update the flow record with snapshot references
-            // Without this, Flow Designer shows an empty flow!
-            console.log('Updating flow with snapshot references...');
-            try {
-                await client.patch(`/api/now/table/${FLOW_TABLES.FLOW}/${flowSysId}`, {
-                    main_snapshot: snapshotSysId,
-                    latest_snapshot: snapshotSysId
-                });
-                console.log(`✅ Flow updated with main_snapshot and latest_snapshot`);
-            }
-            catch (updateError) {
-                errors.push(`Failed to update flow with snapshot references: ${updateError.response?.data?.error?.message || updateError.message}`);
-            }
         }
         catch (error) {
             errors.push(`Failed to create snapshot: ${error.response?.data?.error?.message || error.message}`);
@@ -1243,9 +1181,7 @@ async function handleCreate(args, client, versionInfo) {
             internal_name: internalName,
             active: auto_activate && errors.length === 0,
             url: `${instanceUrl}/sys_hub_flow.do?sys_id=${flowSysId}`,
-            flow_designer_url: `${instanceUrl}/nav_to.do?uri=/flow-designer.do%23/flow/${flowSysId}`,
-            main_snapshot: create_snapshot ? snapshotSysId : undefined,
-            latest_snapshot: create_snapshot ? snapshotSysId : undefined
+            flow_designer_url: `${instanceUrl}/nav_to.do?uri=/$flow-designer.do#/flow/${flowSysId}`
         },
         created_records: createdRecords,
         version_info: versionInfo,
@@ -1386,9 +1322,8 @@ async function handleDelete(args, client, versionInfo) {
     console.log('Deleting triggers...');
     await deleteFromTable(triggerTable, `flow=${flow.sys_id}`);
     // 5. DELETE VARIABLES
-    // Note: sys_hub_flow_variable uses 'model' field (not 'flow')
     console.log('Deleting variables...');
-    await deleteFromTable(FLOW_TABLES.VARIABLE, `model=${flow.sys_id}`);
+    await deleteFromTable(FLOW_TABLES.VARIABLE, `flow=${flow.sys_id}`);
     // 6. DELETE SNAPSHOTS
     console.log('Deleting snapshots...');
     await deleteFromTable(FLOW_TABLES.SNAPSHOT, `flow=${flow.sys_id}`);
@@ -1476,19 +1411,17 @@ async function handleClone(args, client, versionInfo) {
         return (0, error_handler_js_1.createErrorResult)(`Failed to create cloned flow: ${error.response?.data?.error?.message || error.message}`);
     }
     // ==================== 2. CLONE VARIABLES ====================
-    // Note: sys_hub_flow_variable uses 'model' field (not 'flow')
     try {
         const variablesResponse = await client.get(`/api/now/table/${FLOW_TABLES.VARIABLE}`, {
-            params: { sysparm_query: `model=${sourceFlow.sys_id}`, sysparm_orderby: 'order' }
+            params: { sysparm_query: `flow=${sourceFlow.sys_id}`, sysparm_orderby: 'order' }
         });
         if (variablesResponse.data.result) {
             for (const variable of variablesResponse.data.result) {
                 const newVariableId = generateSysId();
                 sysIdMap.set(variable.sys_id, newVariableId);
-                // Note: sys_hub_flow_variable uses 'model' field (not 'flow')
                 const newVariable = {
                     sys_id: newVariableId,
-                    model: newFlowId,
+                    flow: newFlowId,
                     name: variable.name,
                     label: variable.label,
                     description: variable.description,
@@ -1775,57 +1708,25 @@ async function handleClone(args, client, versionInfo) {
         // Subflow table might not exist or be empty
     }
     // ==================== 7. CREATE SNAPSHOT ====================
-    let clonedSnapshotId;
     if (create_snapshot) {
-        clonedSnapshotId = generateSysId();
-        // Build flow definition for snapshot
-        const flowDefinition = {
-            sys_id: newFlowId,
-            name: new_name,
-            internal_name: newInternalName,
-            cloned_from: sourceFlow.sys_id,
-            // Include created components
-            components: createdRecords.map(r => ({
-                table: r.table,
-                sys_id: r.sys_id,
-                name: r.name,
-                type: r.type
-            }))
-        };
+        const snapshotId = generateSysId();
         const snapshotData = {
-            sys_id: clonedSnapshotId,
+            sys_id: snapshotId,
             flow: newFlowId,
             name: `${new_name} - Initial (Cloned)`,
             version: '1.0.0',
             active: true,
-            published: false,
-            // Include flow definition
-            definition: useCompression
-                ? compressValue(flowDefinition, versionInfo.useCompressionHeader)
-                : JSON.stringify(flowDefinition)
+            published: false
         };
         try {
             await client.post(`/api/now/table/${FLOW_TABLES.SNAPSHOT}`, snapshotData);
             createdRecords.push({
                 table: FLOW_TABLES.SNAPSHOT,
-                sys_id: clonedSnapshotId,
+                sys_id: snapshotId,
                 name: snapshotData.name,
                 type: 'snapshot'
             });
-            console.log(`✅ Created snapshot: ${clonedSnapshotId}`);
-            // *** CRITICAL FIX ***
-            // Update the cloned flow with snapshot references
-            console.log('Updating cloned flow with snapshot references...');
-            try {
-                await client.patch(`/api/now/table/${FLOW_TABLES.FLOW}/${newFlowId}`, {
-                    main_snapshot: clonedSnapshotId,
-                    latest_snapshot: clonedSnapshotId
-                });
-                console.log(`✅ Cloned flow updated with main_snapshot and latest_snapshot`);
-            }
-            catch (updateError) {
-                errors.push(`Failed to update cloned flow with snapshot references: ${updateError.message}`);
-            }
+            console.log(`✅ Created snapshot: ${snapshotId}`);
         }
         catch (e) {
             errors.push(`Failed to create snapshot: ${e.message}`);
@@ -1856,9 +1757,7 @@ async function handleClone(args, client, versionInfo) {
             internal_name: newInternalName,
             active: false,
             url: `${instanceUrl}/sys_hub_flow.do?sys_id=${newFlowId}`,
-            flow_designer_url: `${instanceUrl}/nav_to.do?uri=/flow-designer.do%23/flow/${newFlowId}`,
-            main_snapshot: clonedSnapshotId,
-            latest_snapshot: clonedSnapshotId
+            flow_designer_url: `${instanceUrl}/nav_to.do?uri=/$flow-designer.do#/flow/${newFlowId}`
         },
         summary,
         created_records: createdRecords,
@@ -1953,7 +1852,7 @@ async function handleAddAction(args, client, versionInfo) {
         actionData.branch = action_config.branch;
     }
     if (action_config.inputs) {
-        actionData.values = buildActionValues(action_config.inputs, useCompression, versionInfo.useCompressionHeader);
+        actionData.values = buildActionValues(action_config.inputs, useCompression);
     }
     try {
         await client.post(`/api/now/table/${actionTable}`, actionData);
@@ -2106,12 +2005,11 @@ async function handleAddVariable(args, client) {
     }
     const variableSysId = generateSysId();
     // Get max order for variables
-    // Note: sys_hub_flow_variable uses 'model' field (not 'flow')
     let maxOrder = 0;
     try {
         const response = await client.get(`/api/now/table/${FLOW_TABLES.VARIABLE}`, {
             params: {
-                sysparm_query: `model=${flow.sys_id}`,
+                sysparm_query: `flow=${flow.sys_id}`,
                 sysparm_fields: 'order',
                 sysparm_orderby: 'DESCorder',
                 sysparm_limit: 1
@@ -2124,7 +2022,7 @@ async function handleAddVariable(args, client) {
     catch (e) { }
     const variableData = {
         sys_id: variableSysId,
-        model: flow.sys_id,
+        flow: flow.sys_id,
         name: variable_config.name,
         label: variable_config.label || variable_config.name,
         description: variable_config.description || '',
@@ -2237,10 +2135,9 @@ async function handleGetDetails(args, client, versionInfo) {
     }
     catch (e) { }
     // Get variables
-    // Note: sys_hub_flow_variable uses 'model' field (not 'flow')
     try {
         const response = await client.get(`/api/now/table/${FLOW_TABLES.VARIABLE}`, {
-            params: { sysparm_query: `model=${flow.sys_id}`, sysparm_orderby: 'order' }
+            params: { sysparm_query: `flow=${flow.sys_id}`, sysparm_orderby: 'order' }
         });
         if (response.data.result) {
             details.variables = response.data.result;
@@ -2312,66 +2209,14 @@ async function handlePublish(args, client, versionInfo) {
         return (0, error_handler_js_1.createErrorResult)(`Flow not found: ${flow_id || flow_name}`);
     }
     const snapshotSysId = generateSysId();
-    const useCompression = versionInfo.useCompression;
-    // Get existing flow components for the definition
-    const actionTable = versionInfo.useV2Tables ? FLOW_TABLES.ACTION_V2 : FLOW_TABLES.ACTION_V1;
-    const triggerTable = versionInfo.useV2Tables ? FLOW_TABLES.TRIGGER_V2 : FLOW_TABLES.TRIGGER_V1;
-    const logicTable = versionInfo.useV2Tables ? FLOW_TABLES.LOGIC_V2 : FLOW_TABLES.LOGIC_V1;
-    // Fetch existing components
-    let actions = [];
-    let triggers = [];
-    let logic = [];
-    let variables = [];
-    try {
-        const actionsResp = await client.get(`/api/now/table/${actionTable}`, {
-            params: { sysparm_query: `flow=${flow.sys_id}`, sysparm_fields: 'sys_id,name,order' }
-        });
-        actions = actionsResp.data.result || [];
-    }
-    catch (e) { }
-    try {
-        const triggersResp = await client.get(`/api/now/table/${triggerTable}`, {
-            params: { sysparm_query: `flow=${flow.sys_id}`, sysparm_fields: 'sys_id,trigger_type' }
-        });
-        triggers = triggersResp.data.result || [];
-    }
-    catch (e) { }
-    try {
-        const logicResp = await client.get(`/api/now/table/${logicTable}`, {
-            params: { sysparm_query: `flow=${flow.sys_id}`, sysparm_fields: 'sys_id,name,logic_type' }
-        });
-        logic = logicResp.data.result || [];
-    }
-    catch (e) { }
-    try {
-        const variablesResp = await client.get(`/api/now/table/${FLOW_TABLES.VARIABLE}`, {
-            params: { sysparm_query: `model=${flow.sys_id}`, sysparm_fields: 'sys_id,name,type,direction' }
-        });
-        variables = variablesResp.data.result || [];
-    }
-    catch (e) { }
-    // Build flow definition
-    const flowDefinition = {
-        sys_id: flow.sys_id,
-        name: flow.name,
-        internal_name: flow.internal_name,
-        published_at: new Date().toISOString(),
-        triggers: triggers.map(t => ({ sys_id: t.sys_id, trigger_type: t.trigger_type })),
-        actions: actions.map(a => ({ sys_id: a.sys_id, name: a.name, order: a.order })),
-        logic: logic.map(l => ({ sys_id: l.sys_id, name: l.name, logic_type: l.logic_type })),
-        variables: variables.map(v => ({ sys_id: v.sys_id, name: v.name, type: v.type, direction: v.direction }))
-    };
-    // Create new snapshot with definition
+    // Create new snapshot
     const snapshotData = {
         sys_id: snapshotSysId,
         flow: flow.sys_id,
         name: `${flow.name} - Published ${new Date().toISOString()}`,
         version: '1.0.0',
         active: true,
-        published: true,
-        definition: useCompression
-            ? compressValue(flowDefinition, versionInfo.useCompressionHeader)
-            : JSON.stringify(flowDefinition)
+        published: true
     };
     try {
         await client.post(`/api/now/table/${FLOW_TABLES.SNAPSHOT}`, snapshotData);
@@ -2379,14 +2224,11 @@ async function handlePublish(args, client, versionInfo) {
     catch (error) {
         return (0, error_handler_js_1.createErrorResult)(`Failed to create snapshot: ${error.response?.data?.error?.message || error.message}`);
     }
-    // *** CRITICAL FIX ***
-    // Update flow with snapshot references AND activate
+    // Activate flow
     try {
         await client.patch(`/api/now/table/${FLOW_TABLES.FLOW}/${flow.sys_id}`, {
             active: true,
-            status: 'published',
-            main_snapshot: snapshotSysId,
-            latest_snapshot: snapshotSysId
+            status: 'published'
         });
     }
     catch (error) {
@@ -2397,15 +2239,7 @@ async function handlePublish(args, client, versionInfo) {
         flow_id: flow.sys_id,
         flow_name: flow.name,
         snapshot_id: snapshotSysId,
-        main_snapshot: snapshotSysId,
-        latest_snapshot: snapshotSysId,
-        active: true,
-        components_included: {
-            triggers: triggers.length,
-            actions: actions.length,
-            logic: logic.length,
-            variables: variables.length
-        }
+        active: true
     });
 }
 // ==================== MAIN EXECUTOR ====================
@@ -2454,6 +2288,6 @@ async function execute(args, context) {
         return (0, error_handler_js_1.createErrorResult)(`Flow management failed: ${error.message}`);
     }
 }
-exports.version = '2.1.0';
-exports.author = 'Snow-Flow v8.41.13 - Flow Designer Management (snapshot fix)';
+exports.version = '2.1.0-experimental';
+exports.author = 'Snow-Flow v8.41.17 - Flow Designer Management';
 //# sourceMappingURL=snow_manage_flow.js.map