snow-flow 8.41.8 → 8.41.14

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

@@ -0,0 +1,2459 @@
+"use strict";
+/**
+ * snow_manage_flow - Unified Flow Designer Management via Direct Table API
+ *
+ * ⚠️ EXPERIMENTAL: Manages flows by directly manipulating Flow Designer tables.
+ * This approach is NOT officially supported by ServiceNow but enables programmatic flow management.
+ *
+ * Supported Actions:
+ * - create: Create a new flow with triggers, actions, conditions, loops, variables
+ * - update: Update an existing flow's properties
+ * - delete: Delete a flow and all related records
+ * - clone: Clone an existing flow
+ * - activate: Activate a flow
+ * - deactivate: Deactivate a flow
+ * - add_action: Add an action to an existing flow
+ * - remove_action: Remove an action from a flow
+ * - add_condition: Add a conditional logic block (if/then/else)
+ * - add_loop: Add a loop construct (for_each/do_until)
+ * - get_details: Get detailed flow structure including decompressed values
+ *
+ * Features:
+ * - Xanadu+ compression support (GlideCompressionUtil compatible)
+ * - Nested actions within conditions and loops
+ * - Parent-child relationship management
+ * - Version detection for table compatibility
+ *
+ * Flow Designer Table Structure:
+ * - sys_hub_flow: Main flow record
+ * - sys_hub_flow_snapshot: Flow version/snapshot
+ * - sys_hub_trigger_instance_v2: Trigger configuration
+ * - sys_hub_action_instance_v2: Action instances (with compressed values)
+ * - sys_hub_flow_logic_instance_v2: Conditions, loops (with parent_logic_instance)
+ * - sys_hub_flow_variable: Input/output variables
+ * - sys_hub_sub_flow_instance: Subflow references
+ *
+ * @version 2.0.0-experimental
+ * @author Snow-Flow v8.3.0 - Flow Designer Direct Table API
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.author = exports.version = exports.toolDefinition = void 0;
+exports.execute = execute;
+const auth_js_1 = require("../../shared/auth.js");
+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
+ *
+ * CREATE ORDER (parent → children):
+ * 1. sys_hub_flow           - Main flow record
+ * 2. sys_hub_trigger_*      - Triggers (ref: flow)
+ * 3. sys_hub_flow_variable  - Variables (ref: flow)
+ * 4. sys_hub_flow_logic_*   - Conditions/Loops (ref: flow, parent_logic_instance)
+ * 5. sys_hub_action_*       - Actions (ref: flow, parent_logic_instance, branch)
+ * 6. sys_hub_sub_flow_*     - Subflow calls (ref: flow, parent_logic_instance)
+ * 7. sys_hub_flow_snapshot  - Snapshots (ref: flow)
+ *
+ * DELETE ORDER (children → parent, hierarchical):
+ * 1. Actions               - Children of logic
+ * 2. Subflow instances     - Can be nested in logic
+ * 3. Logic instances       - Deepest children first, then parents
+ * 4. Triggers
+ * 5. Variables
+ * 6. Snapshots
+ * 7. Flow                  - Main record last
+ *
+ * VERSION HISTORY:
+ * - Pre-Washington DC: V1 tables (no _v2 suffix)
+ * - Washington DC+:    V2 tables (with _v2 suffix)
+ * - Xanadu+:           V2 tables + compressed values (GZIP + Base64)
+ */
+const FLOW_TABLES = {
+    // === CORE TABLES ===
+    FLOW: 'sys_hub_flow', // Main flow/subflow records
+    SNAPSHOT: 'sys_hub_flow_snapshot', // Version snapshots
+    VARIABLE: 'sys_hub_flow_variable', // Input/output/scratch variables
+    // === V2 TABLES (Washington DC+) ===
+    TRIGGER_V2: 'sys_hub_trigger_instance_v2', // Trigger instances
+    ACTION_V2: 'sys_hub_action_instance_v2', // Action instances (compressed values in Xanadu+)
+    LOGIC_V2: 'sys_hub_flow_logic_instance_v2', // Conditions, loops (supports nesting)
+    // === SUBFLOW TABLES ===
+    SUBFLOW: 'sys_hub_sub_flow_instance', // Subflow call instances
+    // === LEGACY V1 TABLES (Pre-Washington DC) ===
+    TRIGGER_V1: 'sys_hub_trigger_instance',
+    ACTION_V1: 'sys_hub_action_instance',
+    LOGIC_V1: 'sys_hub_flow_logic_instance',
+    // === DEFINITION TABLES (Read-only, for lookups) ===
+    TRIGGER_TYPE: 'sys_hub_trigger_type', // Available trigger types
+    ACTION_TYPE: 'sys_hub_action_type_base', // Available action types
+    // === ADDITIONAL TABLES (May be needed for complex flows) ===
+    STEP_INSTANCE: 'sys_hub_step_instance', // Step configurations
+    FLOW_INPUT: 'sys_hub_flow_input', // Flow inputs (legacy?)
+    FLOW_OUTPUT: 'sys_hub_flow_output', // Flow outputs (legacy?)
+    FLOW_STAGE: 'sys_hub_flow_stage' // Flow stages
+};
+// ==================== TOOL DEFINITION ====================
+exports.toolDefinition = {
+    name: 'snow_manage_flow',
+    description: `Unified Flow Designer management via Direct Table API (EXPERIMENTAL).
+
+⚠️ WARNING: This tool manipulates Flow Designer tables directly.
+This is NOT officially supported by ServiceNow.
+
+Actions:
+- create: Create a new flow with all components
+- update: Update flow properties
+- delete: Delete a flow and all related records
+- clone: Clone an existing flow
+- activate/deactivate: Change flow state
+- add_action: Add an action to a flow
+- remove_action: Remove an action
+- add_condition: Add if/then/else logic
+- add_loop: Add for_each/do_until loop
+- add_variable: Add flow variable
+- get_details: Get flow structure with decompressed values
+- publish: Publish flow changes
+
+Features:
+- Xanadu+ compression support
+- Nested actions in conditions/loops
+- Parent-child relationship management
+- Automatic version detection`,
+    category: 'automation',
+    subcategory: 'flow-designer',
+    use_cases: ['flow-management', 'automation', 'workflow'],
+    complexity: 'advanced',
+    frequency: 'medium',
+    permission: 'write',
+    allowedRoles: ['developer', 'admin'],
+    inputSchema: {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                enum: ['create', 'update', 'delete', 'clone', 'activate', 'deactivate',
+                    'add_action', 'remove_action', 'add_condition', 'add_loop',
+                    'add_variable', 'get_details', 'publish'],
+                description: 'Management action to perform'
+            },
+            flow: {
+                type: 'object',
+                description: '[create] Flow configuration',
+                properties: {
+                    name: { type: 'string' },
+                    internal_name: { type: 'string' },
+                    description: { type: 'string' },
+                    active: { type: 'boolean', default: false },
+                    application_scope: { type: 'string' },
+                    run_as: { type: 'string', enum: ['system', 'user_who_triggers', 'specific_user'] },
+                    run_as_user: { type: 'string' }
+                }
+            },
+            trigger: {
+                type: 'object',
+                description: '[create] Trigger configuration'
+            },
+            actions: {
+                type: 'array',
+                description: '[create] Actions to add',
+                items: { type: 'object' }
+            },
+            conditions: {
+                type: 'array',
+                description: '[create] Conditional logic blocks',
+                items: { type: 'object' }
+            },
+            loops: {
+                type: 'array',
+                description: '[create] Loop constructs',
+                items: { type: 'object' }
+            },
+            variables: {
+                type: 'array',
+                description: '[create] Flow variables',
+                items: { type: 'object' }
+            },
+            flow_id: {
+                type: 'string',
+                description: '[update/delete/clone/activate/deactivate/get_details/add_*] Flow sys_id'
+            },
+            flow_name: {
+                type: 'string',
+                description: '[update/delete/clone/activate/deactivate/get_details/add_*] Flow name (alternative to flow_id)'
+            },
+            updates: {
+                type: 'object',
+                description: '[update] Properties to update'
+            },
+            new_name: {
+                type: 'string',
+                description: '[clone] Name for cloned flow'
+            },
+            action_config: {
+                type: 'object',
+                description: '[add_action] Action to add'
+            },
+            condition_config: {
+                type: 'object',
+                description: '[add_condition] Condition to add'
+            },
+            loop_config: {
+                type: 'object',
+                description: '[add_loop] Loop to add'
+            },
+            variable_config: {
+                type: 'object',
+                description: '[add_variable] Variable to add'
+            },
+            action_id: {
+                type: 'string',
+                description: '[remove_action] Action sys_id to remove'
+            },
+            auto_activate: {
+                type: 'boolean',
+                description: 'Activate after create/update',
+                default: false
+            },
+            create_snapshot: {
+                type: 'boolean',
+                description: 'Create snapshot after changes',
+                default: true
+            },
+            use_compression: {
+                type: 'boolean',
+                description: 'Use compression for values (auto-detected if not specified)'
+            },
+            validate_only: {
+                type: 'boolean',
+                description: 'Validate without making changes',
+                default: false
+            }
+        },
+        required: ['action']
+    }
+};
+// ==================== HELPER FUNCTIONS ====================
+/**
+ * Generate ServiceNow-compatible sys_id
+ */
+function generateSysId() {
+    return crypto.randomBytes(16).toString('hex');
+}
+/**
+ * Generate internal name from display name
+ */
+function generateInternalName(name, prefix = 'x_snfl') {
+    const sanitized = name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '_')
+        .replace(/^_+|_+$/g, '')
+        .substring(0, 40);
+    return `${prefix}_${sanitized}`;
+}
+/**
+ * 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
+ */
+function compressValue(value, useHeader = false) {
+    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;
+    }
+    catch (error) {
+        console.error('Compression failed, returning uncompressed:', error);
+        return jsonStr;
+    }
+}
+/**
+ * Decompress value from Xanadu+ format
+ * Handles both with and without COMPRESSED: header
+ */
+function decompressValue(value) {
+    if (!value) {
+        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
+        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;
+        }
+    }
+    catch (error) {
+        console.error('Decompression failed:', error);
+        return value;
+    }
+}
+/**
+ * Check if value is compressed (with or without header)
+ */
+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);
+}
+/**
+ * Detect ServiceNow version and capabilities
+ */
+async function detectVersion(client) {
+    try {
+        // Check if V2 tables exist by querying them
+        const v2Response = await client.get('/api/now/table/sys_hub_action_instance_v2', {
+            params: { sysparm_limit: 1 }
+        });
+        // 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);
+            }
+        }
+        return {
+            useV2Tables: true,
+            useCompression,
+            useCompressionHeader,
+            version: useCompression ? 'Xanadu+' : 'Washington DC+'
+        };
+    }
+    catch (error) {
+        // V2 tables don't exist, use V1
+        return {
+            useV2Tables: false,
+            useCompression: false,
+            useCompressionHeader: false,
+            version: 'Pre-Washington DC'
+        };
+    }
+}
+/**
+ * Detect if a value is a data pill reference
+ * Data pills use {{action_name.field}} or {{trigger.field}} syntax
+ */
+function isDataPill(value) {
+    if (typeof value !== 'string')
+        return false;
+    return /^\{\{[\w.]+\}\}$/.test(value) || /^\$\{[\w.]+\}$/.test(value);
+}
+/**
+ * Build a data pill reference
+ */
+function buildDataPill(reference, displayValue) {
+    return {
+        value: reference,
+        displayValue: displayValue || reference,
+        valueType: 'pill'
+    };
+}
+/**
+ * Build a reference field value
+ */
+function buildReferenceValue(sysId, displayValue, table) {
+    return {
+        value: sysId,
+        displayValue: displayValue,
+        valueType: 'reference',
+        parameter: {
+            type: 'reference',
+            label: displayValue,
+            mandatory: false,
+            reference: table
+        }
+    };
+}
+/**
+ * Build a script value (for Run Script action)
+ */
+function buildScriptValue(script) {
+    return {
+        value: script,
+        valueType: 'script'
+    };
+}
+/**
+ * Build a condition value (for If/Loop conditions)
+ */
+function buildConditionValue(condition) {
+    return {
+        value: condition,
+        valueType: 'condition'
+    };
+}
+/**
+ * Build a glide list value (multi-select)
+ */
+function buildGlideListValue(values) {
+    return {
+        value: values.join(','),
+        valueType: 'glide_list'
+    };
+}
+/**
+ * Build values JSON for action instance - ENHANCED VERSION
+ * Supports: data pills, references, arrays, scripts, conditions, transforms
+ */
+function buildActionValues(inputs, useCompression, useCompressionHeader = false) {
+    if (!inputs || Object.keys(inputs).length === 0) {
+        const emptyValue = '{}';
+        return useCompression ? compressValue(emptyValue, useCompressionHeader) : emptyValue;
+    }
+    const values = {};
+    for (const [key, value] of Object.entries(inputs)) {
+        // Already in Flow Designer format
+        if (typeof value === 'object' && value !== null && 'value' in value && 'valueType' in value) {
+            values[key] = value;
+            continue;
+        }
+        // Data pill reference ({{...}} or ${...})
+        if (isDataPill(value)) {
+            values[key] = {
+                value: value,
+                displayValue: value,
+                valueType: 'pill'
+            };
+            continue;
+        }
+        // Reference object with sys_id and display
+        if (typeof value === 'object' && value !== null && 'sys_id' in value) {
+            values[key] = {
+                value: value.sys_id,
+                displayValue: value.display_value || value.name || value.sys_id,
+                valueType: 'reference',
+                referenceName: value.table || ''
+            };
+            continue;
+        }
+        // Array value (e.g., for multi-select or list inputs)
+        if (Array.isArray(value)) {
+            if (value.every(v => typeof v === 'string')) {
+                // String array - join as comma-separated
+                values[key] = {
+                    value: value.join(','),
+                    valueType: 'glide_list'
+                };
+            }
+            else if (value.every(v => typeof v === 'object' && 'sys_id' in v)) {
+                // Array of references
+                values[key] = {
+                    value: value.map(v => v.sys_id).join(','),
+                    displayValue: value.map(v => v.display_value || v.name || v.sys_id).join(', '),
+                    valueType: 'reference_list'
+                };
+            }
+            else {
+                // Complex array - serialize
+                values[key] = {
+                    value: JSON.stringify(value),
+                    valueType: 'array'
+                };
+            }
+            continue;
+        }
+        // Object with special type hints
+        if (typeof value === 'object' && value !== null) {
+            if ('_type' in value) {
+                // Handle special types
+                switch (value._type) {
+                    case 'pill':
+                    case 'data_pill':
+                        values[key] = buildDataPill(value.reference, value.display);
+                        break;
+                    case 'reference':
+                        values[key] = buildReferenceValue(value.sys_id, value.display || value.sys_id, value.table);
+                        break;
+                    case 'script':
+                        values[key] = buildScriptValue(value.script || value.value);
+                        break;
+                    case 'condition':
+                        values[key] = buildConditionValue(value.condition || value.value);
+                        break;
+                    case 'glide_list':
+                        values[key] = buildGlideListValue(value.values || []);
+                        break;
+                    case 'transform':
+                        // Transform function applied to a value
+                        values[key] = {
+                            value: value.source,
+                            displayValue: value.display || value.source,
+                            valueType: 'transform',
+                            transform: {
+                                function: value.function,
+                                params: value.params || []
+                            }
+                        };
+                        break;
+                    default:
+                        values[key] = {
+                            value: JSON.stringify(value),
+                            valueType: 'object'
+                        };
+                }
+                continue;
+            }
+            // Generic object
+            values[key] = {
+                value: JSON.stringify(value),
+                valueType: 'object'
+            };
+            continue;
+        }
+        // Boolean value
+        if (typeof value === 'boolean') {
+            values[key] = {
+                value: String(value),
+                valueType: 'boolean'
+            };
+            continue;
+        }
+        // Number value
+        if (typeof value === 'number') {
+            values[key] = {
+                value: String(value),
+                valueType: Number.isInteger(value) ? 'integer' : 'decimal'
+            };
+            continue;
+        }
+        // String value (check for special patterns)
+        if (typeof value === 'string') {
+            // Check if it looks like a date/time
+            if (/^\d{4}-\d{2}-\d{2}/.test(value)) {
+                values[key] = {
+                    value: value,
+                    valueType: value.includes('T') ? 'glide_date_time' : 'glide_date'
+                };
+                continue;
+            }
+            // Check if it looks like a duration (e.g., "1d 2h 30m")
+            if (/^\d+[dhms]\s*/.test(value)) {
+                values[key] = {
+                    value: value,
+                    valueType: 'duration'
+                };
+                continue;
+            }
+            // Regular string
+            values[key] = {
+                value: value,
+                valueType: 'string'
+            };
+            continue;
+        }
+        // Fallback - convert to string
+        values[key] = {
+            value: String(value),
+            valueType: 'string'
+        };
+    }
+    const jsonStr = JSON.stringify(values);
+    return useCompression ? compressValue(jsonStr, useCompressionHeader) : jsonStr;
+}
+/**
+ * Remap sys_ids in values JSON when cloning
+ * Updates data pill references from old flow to new flow
+ */
+function remapValuesForClone(valuesJson, sysIdMap, oldFlowId, newFlowId) {
+    if (!valuesJson)
+        return valuesJson;
+    let values;
+    try {
+        values = JSON.parse(valuesJson);
+    }
+    catch (e) {
+        return valuesJson;
+    }
+    // Recursively update sys_ids and references
+    const updateRefs = (obj) => {
+        if (!obj || typeof obj !== 'object')
+            return obj;
+        if (Array.isArray(obj)) {
+            return obj.map(item => updateRefs(item));
+        }
+        const updated = {};
+        for (const [key, value] of Object.entries(obj)) {
+            if (typeof value === 'string') {
+                // Check if it's a sys_id that needs remapping
+                if (sysIdMap.has(value)) {
+                    updated[key] = sysIdMap.get(value);
+                }
+                // Check if it's a data pill reference
+                else if (value.includes(oldFlowId)) {
+                    updated[key] = value.replace(oldFlowId, newFlowId);
+                }
+                else {
+                    updated[key] = value;
+                }
+            }
+            else if (typeof value === 'object') {
+                updated[key] = updateRefs(value);
+            }
+            else {
+                updated[key] = value;
+            }
+        }
+        return updated;
+    };
+    const remapped = updateRefs(values);
+    return JSON.stringify(remapped);
+}
+/**
+ * Get trigger type sys_id from name
+ */
+async function getTriggerTypeSysId(client, triggerType, when) {
+    const triggerMap = {
+        'record_created': 'Created',
+        'record_updated': 'Updated',
+        'record_deleted': 'Deleted',
+        'record_created_or_updated': 'Created or Updated',
+        'scheduled': 'Scheduled',
+        'api': 'REST API',
+        'inbound_email': 'Inbound Email',
+        'service_catalog': 'Service Catalog'
+    };
+    let searchName = triggerType;
+    if (triggerType === 'record' && when) {
+        searchName = triggerMap[`record_${when}`] || when;
+    }
+    else if (triggerMap[triggerType]) {
+        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_limit: 1,
+                sysparm_fields: 'sys_id,name,description'
+            }
+        });
+        if (response.data.result && response.data.result.length > 0) {
+            return response.data.result[0].sys_id;
+        }
+    }
+    catch (error) {
+        console.error('Failed to get trigger type:', error);
+    }
+    return null;
+}
+/**
+ * Get action type sys_id from name
+ */
+async function getActionTypeSysId(client, actionType) {
+    if (/^[0-9a-f]{32}$/i.test(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_limit: 1,
+                sysparm_fields: 'sys_id,name,description'
+            }
+        });
+        if (response.data.result && response.data.result.length > 0) {
+            const result = response.data.result[0];
+            return { sys_id: result.sys_id, name: result.name };
+        }
+    }
+    catch (error) {
+        console.error('Failed to get action type:', error);
+    }
+    return null;
+}
+/**
+ * Find flow by ID or name
+ */
+async function findFlow(client, flowId, flowName) {
+    if (!flowId && !flowName) {
+        return null;
+    }
+    try {
+        let query = '';
+        if (flowId) {
+            query = `sys_id=${flowId}`;
+        }
+        else if (flowName) {
+            query = `name=${flowName}^ORinternal_name=${flowName}`;
+        }
+        const response = await client.get('/api/now/table/sys_hub_flow', {
+            params: {
+                sysparm_query: query,
+                sysparm_limit: 1
+            }
+        });
+        if (response.data.result && response.data.result.length > 0) {
+            return response.data.result[0];
+        }
+    }
+    catch (error) {
+        console.error('Failed to find flow:', error);
+    }
+    return null;
+}
+/**
+ * Get maximum order number for actions/logic in a flow
+ */
+async function getMaxOrder(client, flowId, table) {
+    try {
+        const response = await client.get(`/api/now/table/${table}`, {
+            params: {
+                sysparm_query: `flow=${flowId}`,
+                sysparm_fields: 'order',
+                sysparm_orderby: 'DESCorder',
+                sysparm_limit: 1
+            }
+        });
+        if (response.data.result && response.data.result.length > 0) {
+            return parseInt(response.data.result[0].order || '0', 10);
+        }
+    }
+    catch (error) {
+        console.error('Failed to get max order:', error);
+    }
+    return 0;
+}
+// ==================== ACTION HANDLERS ====================
+/**
+ * Create a new flow
+ */
+async function handleCreate(args, client, versionInfo) {
+    const { flow: flowConfig, trigger: triggerConfig, actions: actionConfigs = [], conditions = [], loops = [], variables = [], auto_activate = false, create_snapshot = true, use_compression, validate_only = false } = args;
+    if (!flowConfig?.name) {
+        return (0, error_handler_js_1.createErrorResult)('flow.name is required for create action');
+    }
+    const useCompression = use_compression ?? versionInfo.useCompression;
+    const flowSysId = generateSysId();
+    const snapshotSysId = generateSysId();
+    const triggerSysId = generateSysId();
+    const internalName = flowConfig.internal_name || generateInternalName(flowConfig.name);
+    const timestamp = new Date().toISOString();
+    if (validate_only) {
+        return (0, error_handler_js_1.createSuccessResult)({
+            valid: true,
+            would_create: {
+                flow: { sys_id: flowSysId, name: flowConfig.name, internal_name: internalName },
+                snapshot: create_snapshot ? { sys_id: snapshotSysId } : null,
+                trigger: triggerConfig ? { sys_id: triggerSysId, type: triggerConfig.type } : null,
+                actions: actionConfigs.length,
+                conditions: conditions.length,
+                loops: loops.length,
+                variables: variables.length
+            },
+            version_info: versionInfo,
+            compression: useCompression
+        });
+    }
+    const createdRecords = [];
+    const errors = [];
+    // 1. CREATE FLOW RECORD
+    console.log(`Creating flow: ${flowConfig.name}`);
+    const flowData = {
+        sys_id: flowSysId,
+        name: flowConfig.name,
+        internal_name: internalName,
+        description: flowConfig.description || '',
+        active: false,
+        sys_class_name: 'sys_hub_flow',
+        type: 'flow',
+        flow_type: 'flow',
+        status: 'draft',
+        source_ui: 'flow_designer',
+        access: 'public',
+        run_as: flowConfig.run_as || 'system'
+    };
+    if (flowConfig.application_scope && flowConfig.application_scope !== 'global') {
+        flowData.sys_scope = flowConfig.application_scope;
+    }
+    if (flowConfig.run_as_user) {
+        flowData.run_as_user = flowConfig.run_as_user;
+    }
+    try {
+        const flowResponse = await client.post(`/api/now/table/${FLOW_TABLES.FLOW}`, flowData);
+        createdRecords.push({ table: FLOW_TABLES.FLOW, sys_id: flowSysId, name: flowConfig.name });
+        console.log(`✅ Created flow: ${flowSysId}`);
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(`Failed to create flow: ${error.response?.data?.error?.message || error.message}`);
+    }
+    // 2. CREATE TRIGGER
+    if (triggerConfig) {
+        console.log(`Creating trigger: ${triggerConfig.type}`);
+        const triggerTypeSysId = await getTriggerTypeSysId(client, triggerConfig.type, triggerConfig.when);
+        if (!triggerTypeSysId) {
+            errors.push(`Trigger type not found: ${triggerConfig.type}`);
+        }
+        else {
+            const triggerTable = versionInfo.useV2Tables ? FLOW_TABLES.TRIGGER_V2 : FLOW_TABLES.TRIGGER_V1;
+            const triggerData = {
+                sys_id: triggerSysId,
+                flow: flowSysId,
+                trigger_type: triggerTypeSysId,
+                active: true,
+                order: 0
+            };
+            if (triggerConfig.type === 'record') {
+                if (triggerConfig.table)
+                    triggerData.table = triggerConfig.table;
+                if (triggerConfig.condition) {
+                    const conditionValue = { filter_condition: { value: triggerConfig.condition } };
+                    triggerData.values = useCompression ? compressValue(conditionValue) : JSON.stringify(conditionValue);
+                }
+            }
+            if (triggerConfig.type === 'scheduled' && triggerConfig.schedule) {
+                const scheduleValues = {};
+                if (triggerConfig.schedule.frequency)
+                    scheduleValues.frequency = { value: triggerConfig.schedule.frequency };
+                if (triggerConfig.schedule.time)
+                    scheduleValues.time_of_day = { value: triggerConfig.schedule.time };
+                if (triggerConfig.schedule.cron)
+                    scheduleValues.cron_expression = { value: triggerConfig.schedule.cron };
+                triggerData.values = useCompression ? compressValue(scheduleValues) : JSON.stringify(scheduleValues);
+            }
+            try {
+                await client.post(`/api/now/table/${triggerTable}`, triggerData);
+                createdRecords.push({ table: triggerTable, sys_id: triggerSysId, type: triggerConfig.type });
+                console.log(`✅ Created trigger: ${triggerSysId}`);
+            }
+            catch (error) {
+                errors.push(`Failed to create trigger: ${error.response?.data?.error?.message || error.message}`);
+            }
+        }
+    }
+    // 3. CREATE VARIABLES
+    for (let i = 0; i < variables.length; i++) {
+        const variable = variables[i];
+        const variableSysId = generateSysId();
+        console.log(`Creating variable: ${variable.name}`);
+        const typeMap = {
+            'string': 'string', 'integer': 'integer', 'boolean': 'boolean',
+            '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,
+            name: variable.name,
+            label: variable.label || variable.name,
+            description: variable.description || '',
+            type: typeMap[variable.type] || 'string',
+            direction: variable.direction,
+            mandatory: variable.mandatory || false,
+            order: i * 100
+        };
+        if (variable.default_value)
+            variableData.default_value = variable.default_value;
+        if (variable.reference_table)
+            variableData.reference_table = variable.reference_table;
+        try {
+            await client.post(`/api/now/table/${FLOW_TABLES.VARIABLE}`, variableData);
+            createdRecords.push({ table: FLOW_TABLES.VARIABLE, sys_id: variableSysId, name: variable.name });
+            console.log(`✅ Created variable: ${variable.name}`);
+        }
+        catch (error) {
+            errors.push(`Failed to create variable ${variable.name}: ${error.response?.data?.error?.message || error.message}`);
+        }
+    }
+    // 4. CREATE CONDITIONS (with nested actions)
+    const logicTable = versionInfo.useV2Tables ? FLOW_TABLES.LOGIC_V2 : FLOW_TABLES.LOGIC_V1;
+    const actionTable = versionInfo.useV2Tables ? FLOW_TABLES.ACTION_V2 : FLOW_TABLES.ACTION_V1;
+    let currentOrder = 100;
+    for (const condition of conditions) {
+        const conditionSysId = generateSysId();
+        console.log(`Creating condition: ${condition.name || 'Condition'}`);
+        const conditionData = {
+            sys_id: conditionSysId,
+            flow: flowSysId,
+            name: condition.name || 'If',
+            logic_type: 'if',
+            order: condition.order ?? currentOrder,
+            active: true
+        };
+        // Build condition values
+        const conditionValues = {
+            condition: { value: condition.condition, valueType: 'string' }
+        };
+        conditionData.values = useCompression ? compressValue(conditionValues) : JSON.stringify(conditionValues);
+        if (condition.parent_logic_instance) {
+            conditionData.parent_logic_instance = condition.parent_logic_instance;
+        }
+        try {
+            await client.post(`/api/now/table/${logicTable}`, conditionData);
+            createdRecords.push({ table: logicTable, sys_id: conditionSysId, name: condition.name || 'If', type: 'condition' });
+            console.log(`✅ Created condition: ${conditionSysId}`);
+            // Create THEN branch actions
+            if (condition.then_actions && condition.then_actions.length > 0) {
+                let thenOrder = 100;
+                for (const thenAction of condition.then_actions) {
+                    const actionSysId = generateSysId();
+                    const actionType = await getActionTypeSysId(client, thenAction.type);
+                    if (actionType) {
+                        const actionData = {
+                            sys_id: actionSysId,
+                            flow: flowSysId,
+                            action_type: actionType.sys_id,
+                            name: thenAction.name || actionType.name,
+                            description: thenAction.description || '',
+                            order: thenOrder,
+                            active: true,
+                            parent_logic_instance: conditionSysId,
+                            branch: 'then'
+                        };
+                        if (thenAction.inputs) {
+                            actionData.values = buildActionValues(thenAction.inputs, useCompression, versionInfo.useCompressionHeader);
+                        }
+                        try {
+                            await client.post(`/api/now/table/${actionTable}`, actionData);
+                            createdRecords.push({
+                                table: actionTable,
+                                sys_id: actionSysId,
+                                name: thenAction.name || actionType.name,
+                                parent: conditionSysId,
+                                branch: 'then'
+                            });
+                            console.log(`✅ Created then-action: ${actionSysId}`);
+                        }
+                        catch (error) {
+                            errors.push(`Failed to create then-action: ${error.response?.data?.error?.message || error.message}`);
+                        }
+                    }
+                    thenOrder += 100;
+                }
+            }
+            // Create ELSE branch actions
+            if (condition.else_actions && condition.else_actions.length > 0) {
+                let elseOrder = 100;
+                for (const elseAction of condition.else_actions) {
+                    const actionSysId = generateSysId();
+                    const actionType = await getActionTypeSysId(client, elseAction.type);
+                    if (actionType) {
+                        const actionData = {
+                            sys_id: actionSysId,
+                            flow: flowSysId,
+                            action_type: actionType.sys_id,
+                            name: elseAction.name || actionType.name,
+                            description: elseAction.description || '',
+                            order: elseOrder,
+                            active: true,
+                            parent_logic_instance: conditionSysId,
+                            branch: 'else'
+                        };
+                        if (elseAction.inputs) {
+                            actionData.values = buildActionValues(elseAction.inputs, useCompression, versionInfo.useCompressionHeader);
+                        }
+                        try {
+                            await client.post(`/api/now/table/${actionTable}`, actionData);
+                            createdRecords.push({
+                                table: actionTable,
+                                sys_id: actionSysId,
+                                name: elseAction.name || actionType.name,
+                                parent: conditionSysId,
+                                branch: 'else'
+                            });
+                            console.log(`✅ Created else-action: ${actionSysId}`);
+                        }
+                        catch (error) {
+                            errors.push(`Failed to create else-action: ${error.response?.data?.error?.message || error.message}`);
+                        }
+                    }
+                    elseOrder += 100;
+                }
+            }
+        }
+        catch (error) {
+            errors.push(`Failed to create condition: ${error.response?.data?.error?.message || error.message}`);
+        }
+        currentOrder += 100;
+    }
+    // 5. CREATE LOOPS (with nested actions)
+    for (const loop of loops) {
+        const loopSysId = generateSysId();
+        console.log(`Creating loop: ${loop.name || loop.type}`);
+        const loopData = {
+            sys_id: loopSysId,
+            flow: flowSysId,
+            name: loop.name || (loop.type === 'for_each' ? 'For Each' : 'Do Until'),
+            logic_type: loop.type,
+            order: loop.order ?? currentOrder,
+            active: true
+        };
+        // Build loop values
+        const loopValues = {};
+        if (loop.data_source)
+            loopValues.data_source = { value: loop.data_source, valueType: 'reference' };
+        if (loop.condition)
+            loopValues.condition = { value: loop.condition, valueType: 'string' };
+        if (loop.max_iterations)
+            loopValues.max_iterations = { value: String(loop.max_iterations), valueType: 'integer' };
+        if (Object.keys(loopValues).length > 0) {
+            loopData.values = useCompression ? compressValue(loopValues) : JSON.stringify(loopValues);
+        }
+        if (loop.parent_logic_instance) {
+            loopData.parent_logic_instance = loop.parent_logic_instance;
+        }
+        try {
+            await client.post(`/api/now/table/${logicTable}`, loopData);
+            createdRecords.push({ table: logicTable, sys_id: loopSysId, name: loop.name || loop.type, type: 'loop' });
+            console.log(`✅ Created loop: ${loopSysId}`);
+            // Create nested actions within loop
+            if (loop.actions && loop.actions.length > 0) {
+                let loopActionOrder = 100;
+                for (const loopAction of loop.actions) {
+                    const actionSysId = generateSysId();
+                    const actionType = await getActionTypeSysId(client, loopAction.type);
+                    if (actionType) {
+                        const actionData = {
+                            sys_id: actionSysId,
+                            flow: flowSysId,
+                            action_type: actionType.sys_id,
+                            name: loopAction.name || actionType.name,
+                            description: loopAction.description || '',
+                            order: loopActionOrder,
+                            active: true,
+                            parent_logic_instance: loopSysId
+                        };
+                        if (loopAction.inputs) {
+                            actionData.values = buildActionValues(loopAction.inputs, useCompression, versionInfo.useCompressionHeader);
+                        }
+                        try {
+                            await client.post(`/api/now/table/${actionTable}`, actionData);
+                            createdRecords.push({
+                                table: actionTable,
+                                sys_id: actionSysId,
+                                name: loopAction.name || actionType.name,
+                                parent: loopSysId
+                            });
+                            console.log(`✅ Created loop-action: ${actionSysId}`);
+                        }
+                        catch (error) {
+                            errors.push(`Failed to create loop-action: ${error.response?.data?.error?.message || error.message}`);
+                        }
+                    }
+                    loopActionOrder += 100;
+                }
+            }
+        }
+        catch (error) {
+            errors.push(`Failed to create loop: ${error.response?.data?.error?.message || error.message}`);
+        }
+        currentOrder += 100;
+    }
+    // 6. CREATE TOP-LEVEL ACTIONS (not nested in conditions/loops)
+    for (let i = 0; i < actionConfigs.length; i++) {
+        const actionConfig = actionConfigs[i];
+        // Skip if this action is meant to be nested (has parent)
+        if (actionConfig.parent_logic_instance)
+            continue;
+        const actionSysId = generateSysId();
+        console.log(`Creating action: ${actionConfig.type}`);
+        const actionType = await getActionTypeSysId(client, actionConfig.type);
+        if (!actionType) {
+            errors.push(`Action type not found: ${actionConfig.type}`);
+            continue;
+        }
+        const actionData = {
+            sys_id: actionSysId,
+            flow: flowSysId,
+            action_type: actionType.sys_id,
+            name: actionConfig.name || actionType.name,
+            description: actionConfig.description || '',
+            order: actionConfig.order ?? currentOrder,
+            active: true
+        };
+        if (actionConfig.inputs) {
+            actionData.values = buildActionValues(actionConfig.inputs, useCompression, versionInfo.useCompressionHeader);
+        }
+        try {
+            await client.post(`/api/now/table/${actionTable}`, actionData);
+            createdRecords.push({ table: actionTable, sys_id: actionSysId, name: actionConfig.name || actionType.name });
+            console.log(`✅ Created action: ${actionSysId}`);
+        }
+        catch (error) {
+            errors.push(`Failed to create action ${actionConfig.type}: ${error.response?.data?.error?.message || error.message}`);
+        }
+        currentOrder += 100;
+    }
+    // 7. CREATE SNAPSHOT WITH FLOW DEFINITION
+    // This is CRITICAL - Flow Designer requires snapshots with main_snapshot/latest_snapshot references
+    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 }))
+        };
+        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)
+        };
+        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}`);
+        }
+    }
+    // 8. ACTIVATE IF REQUESTED
+    if (auto_activate && errors.length === 0) {
+        console.log('Activating flow...');
+        try {
+            await client.patch(`/api/now/table/${FLOW_TABLES.FLOW}/${flowSysId}`, {
+                active: true,
+                status: 'published'
+            });
+            console.log(`✅ Flow activated`);
+        }
+        catch (error) {
+            errors.push(`Failed to activate: ${error.response?.data?.error?.message || error.message}`);
+        }
+    }
+    const instanceUrl = (client.defaults?.baseURL || '').replace('/api/now', '');
+    return (0, error_handler_js_1.createSuccessResult)({
+        action: 'create',
+        flow: {
+            sys_id: flowSysId,
+            name: flowConfig.name,
+            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
+        },
+        created_records: createdRecords,
+        version_info: versionInfo,
+        compression_used: useCompression,
+        errors: errors.length > 0 ? errors : undefined
+    });
+}
+/**
+ * Update an existing flow
+ */
+async function handleUpdate(args, client, versionInfo) {
+    const { flow_id, flow_name, updates } = args;
+    const flow = await findFlow(client, flow_id, flow_name);
+    if (!flow) {
+        return (0, error_handler_js_1.createErrorResult)(`Flow not found: ${flow_id || flow_name}`);
+    }
+    if (!updates || Object.keys(updates).length === 0) {
+        return (0, error_handler_js_1.createErrorResult)('No updates provided');
+    }
+    try {
+        await client.patch(`/api/now/table/${FLOW_TABLES.FLOW}/${flow.sys_id}`, updates);
+        return (0, error_handler_js_1.createSuccessResult)({
+            action: 'update',
+            flow_id: flow.sys_id,
+            updated_fields: Object.keys(updates)
+        });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(`Failed to update flow: ${error.response?.data?.error?.message || error.message}`);
+    }
+}
+/**
+ * Delete a flow and all related records
+ *
+ * IMPORTANT: Delete order respects parent-child hierarchy:
+ * 1. Actions (children of logic)
+ * 2. Subflow instances (can be nested in logic)
+ * 3. Logic instances - hierarchically (children before parents)
+ * 4. Triggers
+ * 5. Variables
+ * 6. Snapshots
+ * 7. Flow record (last)
+ */
+async function handleDelete(args, client, versionInfo) {
+    const { flow_id, flow_name } = args;
+    const flow = await findFlow(client, flow_id, flow_name);
+    if (!flow) {
+        return (0, error_handler_js_1.createErrorResult)(`Flow not found: ${flow_id || flow_name}`);
+    }
+    const deletedRecords = [];
+    const errors = [];
+    const actionTable = versionInfo.useV2Tables ? FLOW_TABLES.ACTION_V2 : FLOW_TABLES.ACTION_V1;
+    const logicTable = versionInfo.useV2Tables ? FLOW_TABLES.LOGIC_V2 : FLOW_TABLES.LOGIC_V1;
+    const triggerTable = versionInfo.useV2Tables ? FLOW_TABLES.TRIGGER_V2 : FLOW_TABLES.TRIGGER_V1;
+    // Helper function to delete records from a table
+    const deleteFromTable = async (table, query) => {
+        try {
+            const response = await client.get(`/api/now/table/${table}`, {
+                params: { sysparm_query: query, sysparm_fields: 'sys_id' }
+            });
+            if (response.data.result) {
+                for (const record of response.data.result) {
+                    try {
+                        await client.delete(`/api/now/table/${table}/${record.sys_id}`);
+                        deletedRecords.push({ table, sys_id: record.sys_id });
+                    }
+                    catch (e) {
+                        errors.push(`Failed to delete ${table}/${record.sys_id}: ${e.message}`);
+                    }
+                }
+            }
+        }
+        catch (e) {
+            // Table might not exist or be empty - this is OK
+        }
+    };
+    console.log(`Deleting flow: ${flow.name} (${flow.sys_id})`);
+    // 1. DELETE ACTIONS (children of logic instances)
+    console.log('Deleting actions...');
+    await deleteFromTable(actionTable, `flow=${flow.sys_id}`);
+    // 2. DELETE SUBFLOW INSTANCES (can be nested in logic)
+    console.log('Deleting subflow instances...');
+    await deleteFromTable(FLOW_TABLES.SUBFLOW, `flow=${flow.sys_id}`);
+    // 3. DELETE LOGIC INSTANCES - HIERARCHICALLY
+    // First delete children (items WITH parent_logic_instance), then parents
+    console.log('Deleting logic instances (hierarchically)...');
+    try {
+        const logicResponse = await client.get(`/api/now/table/${logicTable}`, {
+            params: {
+                sysparm_query: `flow=${flow.sys_id}`,
+                sysparm_fields: 'sys_id,parent_logic_instance'
+            }
+        });
+        if (logicResponse.data.result) {
+            const logicItems = logicResponse.data.result;
+            // Separate into children (with parent) and parents (without parent)
+            const children = logicItems.filter((item) => item.parent_logic_instance);
+            const parents = logicItems.filter((item) => !item.parent_logic_instance);
+            // Build hierarchy depth map for proper ordering
+            const depthMap = new Map();
+            const getDepth = (item, visited = new Set()) => {
+                if (!item.parent_logic_instance)
+                    return 0;
+                if (visited.has(item.sys_id))
+                    return 0; // Prevent infinite loops
+                visited.add(item.sys_id);
+                const parent = logicItems.find((p) => p.sys_id === item.parent_logic_instance);
+                if (!parent)
+                    return 1;
+                return 1 + getDepth(parent, visited);
+            };
+            // Calculate depth for each item
+            for (const item of logicItems) {
+                depthMap.set(item.sys_id, getDepth(item));
+            }
+            // Sort by depth descending (deepest children first)
+            const sortedLogic = [...logicItems].sort((a, b) => {
+                const depthA = depthMap.get(a.sys_id) || 0;
+                const depthB = depthMap.get(b.sys_id) || 0;
+                return depthB - depthA; // Deepest first
+            });
+            // Delete in sorted order (deepest children first)
+            for (const logic of sortedLogic) {
+                try {
+                    await client.delete(`/api/now/table/${logicTable}/${logic.sys_id}`);
+                    deletedRecords.push({ table: logicTable, sys_id: logic.sys_id });
+                }
+                catch (e) {
+                    errors.push(`Failed to delete logic ${logic.sys_id}: ${e.message}`);
+                }
+            }
+        }
+    }
+    catch (e) {
+        errors.push(`Failed to fetch logic instances: ${e.message}`);
+    }
+    // 4. DELETE TRIGGERS
+    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}`);
+    // 6. DELETE SNAPSHOTS
+    console.log('Deleting snapshots...');
+    await deleteFromTable(FLOW_TABLES.SNAPSHOT, `flow=${flow.sys_id}`);
+    // 7. DELETE FLOW RECORD (last)
+    console.log('Deleting flow record...');
+    try {
+        await client.delete(`/api/now/table/${FLOW_TABLES.FLOW}/${flow.sys_id}`);
+        deletedRecords.push({ table: FLOW_TABLES.FLOW, sys_id: flow.sys_id });
+        console.log(`✅ Flow deleted: ${flow.sys_id}`);
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(`Failed to delete flow: ${error.response?.data?.error?.message || error.message}`);
+    }
+    return (0, error_handler_js_1.createSuccessResult)({
+        action: 'delete',
+        flow_id: flow.sys_id,
+        flow_name: flow.name,
+        deleted_records: deletedRecords,
+        delete_order: [
+            'actions',
+            'subflow_instances',
+            'logic_instances (hierarchical)',
+            'triggers',
+            'variables',
+            'snapshots',
+            'flow'
+        ],
+        errors: errors.length > 0 ? errors : undefined
+    });
+}
+/**
+ * Clone a flow - FULL IMPLEMENTATION
+ * Copies ALL components: flow, triggers, actions, logic, variables, subflows
+ * Maintains parent-child relationships and remaps sys_ids
+ */
+async function handleClone(args, client, versionInfo) {
+    const { flow_id, flow_name, new_name, use_compression, create_snapshot = true } = args;
+    const sourceFlow = await findFlow(client, flow_id, flow_name);
+    if (!sourceFlow) {
+        return (0, error_handler_js_1.createErrorResult)(`Flow not found: ${flow_id || flow_name}`);
+    }
+    if (!new_name) {
+        return (0, error_handler_js_1.createErrorResult)('new_name is required for clone action');
+    }
+    const useCompression = use_compression ?? versionInfo.useCompression;
+    const triggerTable = versionInfo.useV2Tables ? FLOW_TABLES.TRIGGER_V2 : FLOW_TABLES.TRIGGER_V1;
+    const actionTable = versionInfo.useV2Tables ? FLOW_TABLES.ACTION_V2 : FLOW_TABLES.ACTION_V1;
+    const logicTable = versionInfo.useV2Tables ? FLOW_TABLES.LOGIC_V2 : FLOW_TABLES.LOGIC_V1;
+    // Map old sys_ids to new sys_ids for remapping references
+    const sysIdMap = new Map();
+    const createdRecords = [];
+    const errors = [];
+    // Generate new IDs
+    const newFlowId = generateSysId();
+    const newInternalName = generateInternalName(new_name);
+    sysIdMap.set(sourceFlow.sys_id, newFlowId);
+    console.log(`Cloning flow: ${sourceFlow.name} -> ${new_name}`);
+    // ==================== 1. CLONE FLOW RECORD ====================
+    const newFlowData = {
+        sys_id: newFlowId,
+        name: new_name,
+        internal_name: newInternalName,
+        description: `Cloned from: ${sourceFlow.name}\n\n${sourceFlow.description || ''}`,
+        active: false,
+        sys_class_name: 'sys_hub_flow',
+        type: sourceFlow.type || 'flow',
+        flow_type: sourceFlow.flow_type || 'flow',
+        status: 'draft',
+        source_ui: 'flow_designer',
+        access: sourceFlow.access || 'public',
+        run_as: sourceFlow.run_as || 'system'
+    };
+    if (sourceFlow.sys_scope) {
+        newFlowData.sys_scope = sourceFlow.sys_scope;
+    }
+    if (sourceFlow.run_as_user) {
+        newFlowData.run_as_user = sourceFlow.run_as_user;
+    }
+    try {
+        await client.post(`/api/now/table/${FLOW_TABLES.FLOW}`, newFlowData);
+        createdRecords.push({ table: FLOW_TABLES.FLOW, sys_id: newFlowId, name: new_name, type: 'flow' });
+        console.log(`✅ Cloned flow record: ${newFlowId}`);
+    }
+    catch (error) {
+        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' }
+        });
+        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,
+                    name: variable.name,
+                    label: variable.label,
+                    description: variable.description,
+                    type: variable.type,
+                    direction: variable.direction,
+                    mandatory: variable.mandatory,
+                    order: variable.order,
+                    default_value: variable.default_value,
+                    reference_table: variable.reference_table
+                };
+                try {
+                    await client.post(`/api/now/table/${FLOW_TABLES.VARIABLE}`, newVariable);
+                    createdRecords.push({
+                        table: FLOW_TABLES.VARIABLE,
+                        sys_id: newVariableId,
+                        name: variable.name,
+                        type: 'variable'
+                    });
+                    console.log(`✅ Cloned variable: ${variable.name}`);
+                }
+                catch (e) {
+                    errors.push(`Failed to clone variable ${variable.name}: ${e.message}`);
+                }
+            }
+        }
+    }
+    catch (e) {
+        errors.push(`Failed to fetch variables: ${e.message}`);
+    }
+    // ==================== 3. CLONE TRIGGERS ====================
+    try {
+        const triggersResponse = await client.get(`/api/now/table/${triggerTable}`, {
+            params: { sysparm_query: `flow=${sourceFlow.sys_id}` }
+        });
+        if (triggersResponse.data.result) {
+            for (const trigger of triggersResponse.data.result) {
+                const newTriggerId = generateSysId();
+                sysIdMap.set(trigger.sys_id, newTriggerId);
+                // Decompress and remap values if needed
+                let newValues = trigger.values;
+                if (newValues) {
+                    if (isCompressed(newValues)) {
+                        const decompressed = decompressValue(newValues);
+                        const remapped = remapValuesForClone(decompressed, sysIdMap, sourceFlow.sys_id, newFlowId);
+                        newValues = useCompression ? compressValue(remapped) : remapped;
+                    }
+                    else {
+                        newValues = remapValuesForClone(newValues, sysIdMap, sourceFlow.sys_id, newFlowId);
+                        if (useCompression)
+                            newValues = compressValue(newValues);
+                    }
+                }
+                const newTrigger = {
+                    sys_id: newTriggerId,
+                    flow: newFlowId,
+                    trigger_type: trigger.trigger_type,
+                    table: trigger.table,
+                    active: trigger.active,
+                    order: trigger.order,
+                    values: newValues
+                };
+                try {
+                    await client.post(`/api/now/table/${triggerTable}`, newTrigger);
+                    createdRecords.push({
+                        table: triggerTable,
+                        sys_id: newTriggerId,
+                        type: 'trigger',
+                        trigger_type: trigger.trigger_type
+                    });
+                    console.log(`✅ Cloned trigger: ${newTriggerId}`);
+                }
+                catch (e) {
+                    errors.push(`Failed to clone trigger: ${e.message}`);
+                }
+            }
+        }
+    }
+    catch (e) {
+        errors.push(`Failed to fetch triggers: ${e.message}`);
+    }
+    // ==================== 4. CLONE LOGIC (CONDITIONS/LOOPS) ====================
+    // First pass: create all logic instances and map sys_ids
+    const logicItems = [];
+    try {
+        const logicResponse = await client.get(`/api/now/table/${logicTable}`, {
+            params: { sysparm_query: `flow=${sourceFlow.sys_id}`, sysparm_orderby: 'order' }
+        });
+        if (logicResponse.data.result) {
+            // First pass: generate new IDs for all logic items
+            for (const logic of logicResponse.data.result) {
+                const newLogicId = generateSysId();
+                sysIdMap.set(logic.sys_id, newLogicId);
+                logicItems.push({ ...logic, newSysId: newLogicId });
+            }
+            // Second pass: create logic items with remapped parent references
+            for (const logic of logicItems) {
+                // Decompress and remap values
+                let newValues = logic.values;
+                if (newValues) {
+                    if (isCompressed(newValues)) {
+                        const decompressed = decompressValue(newValues);
+                        const remapped = remapValuesForClone(decompressed, sysIdMap, sourceFlow.sys_id, newFlowId);
+                        newValues = useCompression ? compressValue(remapped) : remapped;
+                    }
+                    else {
+                        newValues = remapValuesForClone(newValues, sysIdMap, sourceFlow.sys_id, newFlowId);
+                        if (useCompression)
+                            newValues = compressValue(newValues);
+                    }
+                }
+                // Remap parent_logic_instance if it exists
+                let newParentLogic = null;
+                if (logic.parent_logic_instance) {
+                    newParentLogic = sysIdMap.get(logic.parent_logic_instance) || logic.parent_logic_instance;
+                }
+                const newLogic = {
+                    sys_id: logic.newSysId,
+                    flow: newFlowId,
+                    name: logic.name,
+                    logic_type: logic.logic_type,
+                    order: logic.order,
+                    active: logic.active,
+                    values: newValues,
+                    condition: logic.condition
+                };
+                if (newParentLogic) {
+                    newLogic.parent_logic_instance = newParentLogic;
+                }
+                if (logic.branch) {
+                    newLogic.branch = logic.branch;
+                }
+                try {
+                    await client.post(`/api/now/table/${logicTable}`, newLogic);
+                    createdRecords.push({
+                        table: logicTable,
+                        sys_id: logic.newSysId,
+                        name: logic.name,
+                        type: 'logic',
+                        logic_type: logic.logic_type
+                    });
+                    console.log(`✅ Cloned logic: ${logic.name} (${logic.logic_type})`);
+                }
+                catch (e) {
+                    errors.push(`Failed to clone logic ${logic.name}: ${e.message}`);
+                }
+            }
+        }
+    }
+    catch (e) {
+        errors.push(`Failed to fetch logic: ${e.message}`);
+    }
+    // ==================== 5. CLONE ACTIONS ====================
+    try {
+        const actionsResponse = await client.get(`/api/now/table/${actionTable}`, {
+            params: { sysparm_query: `flow=${sourceFlow.sys_id}`, sysparm_orderby: 'order' }
+        });
+        if (actionsResponse.data.result) {
+            // First pass: generate new IDs
+            const actionItems = [];
+            for (const action of actionsResponse.data.result) {
+                const newActionId = generateSysId();
+                sysIdMap.set(action.sys_id, newActionId);
+                actionItems.push({ ...action, newSysId: newActionId });
+            }
+            // Second pass: create actions with remapped references
+            for (const action of actionItems) {
+                // Decompress and remap values
+                let newValues = action.values;
+                if (newValues) {
+                    if (isCompressed(newValues)) {
+                        const decompressed = decompressValue(newValues);
+                        const remapped = remapValuesForClone(decompressed, sysIdMap, sourceFlow.sys_id, newFlowId);
+                        newValues = useCompression ? compressValue(remapped) : remapped;
+                    }
+                    else {
+                        newValues = remapValuesForClone(newValues, sysIdMap, sourceFlow.sys_id, newFlowId);
+                        if (useCompression)
+                            newValues = compressValue(newValues);
+                    }
+                }
+                // Remap parent_logic_instance if it exists
+                let newParentLogic = null;
+                if (action.parent_logic_instance) {
+                    newParentLogic = sysIdMap.get(action.parent_logic_instance) || action.parent_logic_instance;
+                }
+                const newAction = {
+                    sys_id: action.newSysId,
+                    flow: newFlowId,
+                    action_type: action.action_type,
+                    name: action.name,
+                    description: action.description,
+                    order: action.order,
+                    active: action.active,
+                    values: newValues
+                };
+                if (newParentLogic) {
+                    newAction.parent_logic_instance = newParentLogic;
+                }
+                if (action.branch) {
+                    newAction.branch = action.branch;
+                }
+                try {
+                    await client.post(`/api/now/table/${actionTable}`, newAction);
+                    createdRecords.push({
+                        table: actionTable,
+                        sys_id: action.newSysId,
+                        name: action.name,
+                        type: 'action',
+                        action_type: action.action_type
+                    });
+                    console.log(`✅ Cloned action: ${action.name}`);
+                }
+                catch (e) {
+                    errors.push(`Failed to clone action ${action.name}: ${e.message}`);
+                }
+            }
+        }
+    }
+    catch (e) {
+        errors.push(`Failed to fetch actions: ${e.message}`);
+    }
+    // ==================== 6. CLONE SUBFLOW INSTANCES ====================
+    try {
+        const subflowsResponse = await client.get(`/api/now/table/${FLOW_TABLES.SUBFLOW}`, {
+            params: { sysparm_query: `flow=${sourceFlow.sys_id}` }
+        });
+        if (subflowsResponse.data.result) {
+            for (const subflow of subflowsResponse.data.result) {
+                const newSubflowId = generateSysId();
+                sysIdMap.set(subflow.sys_id, newSubflowId);
+                // Decompress and remap values
+                let newValues = subflow.values;
+                if (newValues) {
+                    if (isCompressed(newValues)) {
+                        const decompressed = decompressValue(newValues);
+                        const remapped = remapValuesForClone(decompressed, sysIdMap, sourceFlow.sys_id, newFlowId);
+                        newValues = useCompression ? compressValue(remapped) : remapped;
+                    }
+                    else {
+                        newValues = remapValuesForClone(newValues, sysIdMap, sourceFlow.sys_id, newFlowId);
+                        if (useCompression)
+                            newValues = compressValue(newValues);
+                    }
+                }
+                // Remap parent_logic_instance if it exists
+                let newParentLogic = null;
+                if (subflow.parent_logic_instance) {
+                    newParentLogic = sysIdMap.get(subflow.parent_logic_instance) || subflow.parent_logic_instance;
+                }
+                const newSubflow = {
+                    sys_id: newSubflowId,
+                    flow: newFlowId,
+                    sub_flow: subflow.sub_flow, // Reference to the actual subflow definition
+                    name: subflow.name,
+                    description: subflow.description,
+                    order: subflow.order,
+                    active: subflow.active,
+                    values: newValues
+                };
+                if (newParentLogic) {
+                    newSubflow.parent_logic_instance = newParentLogic;
+                }
+                if (subflow.branch) {
+                    newSubflow.branch = subflow.branch;
+                }
+                try {
+                    await client.post(`/api/now/table/${FLOW_TABLES.SUBFLOW}`, newSubflow);
+                    createdRecords.push({
+                        table: FLOW_TABLES.SUBFLOW,
+                        sys_id: newSubflowId,
+                        name: subflow.name,
+                        type: 'subflow_instance',
+                        sub_flow: subflow.sub_flow
+                    });
+                    console.log(`✅ Cloned subflow instance: ${subflow.name}`);
+                }
+                catch (e) {
+                    errors.push(`Failed to clone subflow instance ${subflow.name}: ${e.message}`);
+                }
+            }
+        }
+    }
+    catch (e) {
+        // 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 snapshotData = {
+            sys_id: clonedSnapshotId,
+            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)
+        };
+        try {
+            await client.post(`/api/now/table/${FLOW_TABLES.SNAPSHOT}`, snapshotData);
+            createdRecords.push({
+                table: FLOW_TABLES.SNAPSHOT,
+                sys_id: clonedSnapshotId,
+                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}`);
+            }
+        }
+        catch (e) {
+            errors.push(`Failed to create snapshot: ${e.message}`);
+        }
+    }
+    // ==================== BUILD RESULT ====================
+    const instanceUrl = (client.defaults?.baseURL || '').replace('/api/now', '');
+    // Summary statistics
+    const summary = {
+        flow: 1,
+        variables: createdRecords.filter(r => r.type === 'variable').length,
+        triggers: createdRecords.filter(r => r.type === 'trigger').length,
+        logic: createdRecords.filter(r => r.type === 'logic').length,
+        actions: createdRecords.filter(r => r.type === 'action').length,
+        subflow_instances: createdRecords.filter(r => r.type === 'subflow_instance').length,
+        snapshots: createdRecords.filter(r => r.type === 'snapshot').length,
+        total: createdRecords.length
+    };
+    return (0, error_handler_js_1.createSuccessResult)({
+        action: 'clone',
+        source_flow: {
+            sys_id: sourceFlow.sys_id,
+            name: sourceFlow.name
+        },
+        cloned_flow: {
+            sys_id: newFlowId,
+            name: new_name,
+            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
+        },
+        summary,
+        created_records: createdRecords,
+        sys_id_mapping: Object.fromEntries(sysIdMap),
+        version_info: versionInfo,
+        compression_used: useCompression,
+        errors: errors.length > 0 ? errors : undefined
+    });
+}
+/**
+ * Activate a flow
+ */
+async function handleActivate(args, client) {
+    const { flow_id, flow_name } = args;
+    const flow = await findFlow(client, flow_id, flow_name);
+    if (!flow) {
+        return (0, error_handler_js_1.createErrorResult)(`Flow not found: ${flow_id || flow_name}`);
+    }
+    try {
+        await client.patch(`/api/now/table/${FLOW_TABLES.FLOW}/${flow.sys_id}`, {
+            active: true,
+            status: 'published'
+        });
+        return (0, error_handler_js_1.createSuccessResult)({
+            action: 'activate',
+            flow_id: flow.sys_id,
+            flow_name: flow.name,
+            active: true
+        });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(`Failed to activate: ${error.response?.data?.error?.message || error.message}`);
+    }
+}
+/**
+ * Deactivate a flow
+ */
+async function handleDeactivate(args, client) {
+    const { flow_id, flow_name } = args;
+    const flow = await findFlow(client, flow_id, flow_name);
+    if (!flow) {
+        return (0, error_handler_js_1.createErrorResult)(`Flow not found: ${flow_id || flow_name}`);
+    }
+    try {
+        await client.patch(`/api/now/table/${FLOW_TABLES.FLOW}/${flow.sys_id}`, {
+            active: false
+        });
+        return (0, error_handler_js_1.createSuccessResult)({
+            action: 'deactivate',
+            flow_id: flow.sys_id,
+            flow_name: flow.name,
+            active: false
+        });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(`Failed to deactivate: ${error.response?.data?.error?.message || error.message}`);
+    }
+}
+/**
+ * Add an action to an existing flow
+ */
+async function handleAddAction(args, client, versionInfo) {
+    const { flow_id, flow_name, action_config, use_compression } = args;
+    const flow = await findFlow(client, flow_id, flow_name);
+    if (!flow) {
+        return (0, error_handler_js_1.createErrorResult)(`Flow not found: ${flow_id || flow_name}`);
+    }
+    if (!action_config?.type) {
+        return (0, error_handler_js_1.createErrorResult)('action_config.type is required');
+    }
+    const useCompression = use_compression ?? versionInfo.useCompression;
+    const actionTable = versionInfo.useV2Tables ? FLOW_TABLES.ACTION_V2 : FLOW_TABLES.ACTION_V1;
+    const actionSysId = generateSysId();
+    const actionType = await getActionTypeSysId(client, action_config.type);
+    if (!actionType) {
+        return (0, error_handler_js_1.createErrorResult)(`Action type not found: ${action_config.type}`);
+    }
+    const maxOrder = await getMaxOrder(client, flow.sys_id, actionTable);
+    const actionData = {
+        sys_id: actionSysId,
+        flow: flow.sys_id,
+        action_type: actionType.sys_id,
+        name: action_config.name || actionType.name,
+        description: action_config.description || '',
+        order: action_config.order ?? (maxOrder + 100),
+        active: true
+    };
+    if (action_config.parent_logic_instance) {
+        actionData.parent_logic_instance = action_config.parent_logic_instance;
+    }
+    if (action_config.branch) {
+        actionData.branch = action_config.branch;
+    }
+    if (action_config.inputs) {
+        actionData.values = buildActionValues(action_config.inputs, useCompression, versionInfo.useCompressionHeader);
+    }
+    try {
+        await client.post(`/api/now/table/${actionTable}`, actionData);
+        return (0, error_handler_js_1.createSuccessResult)({
+            action: 'add_action',
+            flow_id: flow.sys_id,
+            added_action: {
+                sys_id: actionSysId,
+                name: action_config.name || actionType.name,
+                type: action_config.type,
+                order: actionData.order
+            }
+        });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(`Failed to add action: ${error.response?.data?.error?.message || error.message}`);
+    }
+}
+/**
+ * Remove an action from a flow
+ */
+async function handleRemoveAction(args, client, versionInfo) {
+    const { action_id } = args;
+    if (!action_id) {
+        return (0, error_handler_js_1.createErrorResult)('action_id is required');
+    }
+    const actionTable = versionInfo.useV2Tables ? FLOW_TABLES.ACTION_V2 : FLOW_TABLES.ACTION_V1;
+    try {
+        await client.delete(`/api/now/table/${actionTable}/${action_id}`);
+        return (0, error_handler_js_1.createSuccessResult)({
+            action: 'remove_action',
+            action_id,
+            removed: true
+        });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(`Failed to remove action: ${error.response?.data?.error?.message || error.message}`);
+    }
+}
+/**
+ * Add a condition to an existing flow
+ */
+async function handleAddCondition(args, client, versionInfo) {
+    const { flow_id, flow_name, condition_config, use_compression } = args;
+    const flow = await findFlow(client, flow_id, flow_name);
+    if (!flow) {
+        return (0, error_handler_js_1.createErrorResult)(`Flow not found: ${flow_id || flow_name}`);
+    }
+    if (!condition_config?.condition) {
+        return (0, error_handler_js_1.createErrorResult)('condition_config.condition is required');
+    }
+    const useCompression = use_compression ?? versionInfo.useCompression;
+    const logicTable = versionInfo.useV2Tables ? FLOW_TABLES.LOGIC_V2 : FLOW_TABLES.LOGIC_V1;
+    const conditionSysId = generateSysId();
+    const maxOrder = await getMaxOrder(client, flow.sys_id, logicTable);
+    const conditionData = {
+        sys_id: conditionSysId,
+        flow: flow.sys_id,
+        name: condition_config.name || 'If',
+        logic_type: 'if',
+        order: condition_config.order ?? (maxOrder + 100),
+        active: true
+    };
+    const conditionValues = { condition: { value: condition_config.condition, valueType: 'string' } };
+    conditionData.values = useCompression ? compressValue(conditionValues) : JSON.stringify(conditionValues);
+    if (condition_config.parent_logic_instance) {
+        conditionData.parent_logic_instance = condition_config.parent_logic_instance;
+    }
+    try {
+        await client.post(`/api/now/table/${logicTable}`, conditionData);
+        return (0, error_handler_js_1.createSuccessResult)({
+            action: 'add_condition',
+            flow_id: flow.sys_id,
+            condition: {
+                sys_id: conditionSysId,
+                name: condition_config.name || 'If',
+                order: conditionData.order
+            }
+        });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(`Failed to add condition: ${error.response?.data?.error?.message || error.message}`);
+    }
+}
+/**
+ * Add a loop to an existing flow
+ */
+async function handleAddLoop(args, client, versionInfo) {
+    const { flow_id, flow_name, loop_config, use_compression } = args;
+    const flow = await findFlow(client, flow_id, flow_name);
+    if (!flow) {
+        return (0, error_handler_js_1.createErrorResult)(`Flow not found: ${flow_id || flow_name}`);
+    }
+    if (!loop_config?.type) {
+        return (0, error_handler_js_1.createErrorResult)('loop_config.type is required');
+    }
+    const useCompression = use_compression ?? versionInfo.useCompression;
+    const logicTable = versionInfo.useV2Tables ? FLOW_TABLES.LOGIC_V2 : FLOW_TABLES.LOGIC_V1;
+    const loopSysId = generateSysId();
+    const maxOrder = await getMaxOrder(client, flow.sys_id, logicTable);
+    const loopData = {
+        sys_id: loopSysId,
+        flow: flow.sys_id,
+        name: loop_config.name || (loop_config.type === 'for_each' ? 'For Each' : 'Do Until'),
+        logic_type: loop_config.type,
+        order: loop_config.order ?? (maxOrder + 100),
+        active: true
+    };
+    const loopValues = {};
+    if (loop_config.data_source)
+        loopValues.data_source = { value: loop_config.data_source, valueType: 'reference' };
+    if (loop_config.condition)
+        loopValues.condition = { value: loop_config.condition, valueType: 'string' };
+    if (loop_config.max_iterations)
+        loopValues.max_iterations = { value: String(loop_config.max_iterations), valueType: 'integer' };
+    if (Object.keys(loopValues).length > 0) {
+        loopData.values = useCompression ? compressValue(loopValues) : JSON.stringify(loopValues);
+    }
+    if (loop_config.parent_logic_instance) {
+        loopData.parent_logic_instance = loop_config.parent_logic_instance;
+    }
+    try {
+        await client.post(`/api/now/table/${logicTable}`, loopData);
+        return (0, error_handler_js_1.createSuccessResult)({
+            action: 'add_loop',
+            flow_id: flow.sys_id,
+            loop: {
+                sys_id: loopSysId,
+                name: loopData.name,
+                type: loop_config.type,
+                order: loopData.order
+            }
+        });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(`Failed to add loop: ${error.response?.data?.error?.message || error.message}`);
+    }
+}
+/**
+ * Add a variable to an existing flow
+ */
+async function handleAddVariable(args, client) {
+    const { flow_id, flow_name, variable_config } = args;
+    const flow = await findFlow(client, flow_id, flow_name);
+    if (!flow) {
+        return (0, error_handler_js_1.createErrorResult)(`Flow not found: ${flow_id || flow_name}`);
+    }
+    if (!variable_config?.name || !variable_config?.type || !variable_config?.direction) {
+        return (0, error_handler_js_1.createErrorResult)('variable_config requires name, type, and direction');
+    }
+    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_fields: 'order',
+                sysparm_orderby: 'DESCorder',
+                sysparm_limit: 1
+            }
+        });
+        if (response.data.result && response.data.result.length > 0) {
+            maxOrder = parseInt(response.data.result[0].order || '0', 10);
+        }
+    }
+    catch (e) { }
+    const variableData = {
+        sys_id: variableSysId,
+        model: flow.sys_id,
+        name: variable_config.name,
+        label: variable_config.label || variable_config.name,
+        description: variable_config.description || '',
+        type: variable_config.type,
+        direction: variable_config.direction,
+        mandatory: variable_config.mandatory || false,
+        order: maxOrder + 100
+    };
+    if (variable_config.default_value)
+        variableData.default_value = variable_config.default_value;
+    if (variable_config.reference_table)
+        variableData.reference_table = variable_config.reference_table;
+    try {
+        await client.post(`/api/now/table/${FLOW_TABLES.VARIABLE}`, variableData);
+        return (0, error_handler_js_1.createSuccessResult)({
+            action: 'add_variable',
+            flow_id: flow.sys_id,
+            variable: {
+                sys_id: variableSysId,
+                name: variable_config.name,
+                type: variable_config.type,
+                direction: variable_config.direction
+            }
+        });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(`Failed to add variable: ${error.response?.data?.error?.message || error.message}`);
+    }
+}
+/**
+ * Get detailed flow structure with decompressed values
+ */
+async function handleGetDetails(args, client, versionInfo) {
+    const { flow_id, flow_name } = args;
+    const flow = await findFlow(client, flow_id, flow_name);
+    if (!flow) {
+        return (0, error_handler_js_1.createErrorResult)(`Flow not found: ${flow_id || flow_name}`);
+    }
+    const details = {
+        flow: flow,
+        trigger: null,
+        actions: [],
+        logic: [],
+        variables: [],
+        snapshots: []
+    };
+    // Get trigger
+    const triggerTable = versionInfo.useV2Tables ? FLOW_TABLES.TRIGGER_V2 : FLOW_TABLES.TRIGGER_V1;
+    try {
+        const response = await client.get(`/api/now/table/${triggerTable}`, {
+            params: { sysparm_query: `flow=${flow.sys_id}` }
+        });
+        if (response.data.result && response.data.result.length > 0) {
+            const trigger = response.data.result[0];
+            if (trigger.values && isCompressed(trigger.values)) {
+                trigger.values_decompressed = JSON.parse(decompressValue(trigger.values));
+            }
+            else if (trigger.values) {
+                try {
+                    trigger.values_parsed = JSON.parse(trigger.values);
+                }
+                catch (e) { }
+            }
+            details.trigger = trigger;
+        }
+    }
+    catch (e) { }
+    // Get actions
+    const actionTable = versionInfo.useV2Tables ? FLOW_TABLES.ACTION_V2 : FLOW_TABLES.ACTION_V1;
+    try {
+        const response = await client.get(`/api/now/table/${actionTable}`, {
+            params: { sysparm_query: `flow=${flow.sys_id}`, sysparm_orderby: 'order' }
+        });
+        if (response.data.result) {
+            details.actions = response.data.result.map((action) => {
+                if (action.values && isCompressed(action.values)) {
+                    action.values_decompressed = JSON.parse(decompressValue(action.values));
+                }
+                else if (action.values) {
+                    try {
+                        action.values_parsed = JSON.parse(action.values);
+                    }
+                    catch (e) { }
+                }
+                return action;
+            });
+        }
+    }
+    catch (e) { }
+    // Get logic (conditions, loops)
+    const logicTable = versionInfo.useV2Tables ? FLOW_TABLES.LOGIC_V2 : FLOW_TABLES.LOGIC_V1;
+    try {
+        const response = await client.get(`/api/now/table/${logicTable}`, {
+            params: { sysparm_query: `flow=${flow.sys_id}`, sysparm_orderby: 'order' }
+        });
+        if (response.data.result) {
+            details.logic = response.data.result.map((logic) => {
+                if (logic.values && isCompressed(logic.values)) {
+                    logic.values_decompressed = JSON.parse(decompressValue(logic.values));
+                }
+                else if (logic.values) {
+                    try {
+                        logic.values_parsed = JSON.parse(logic.values);
+                    }
+                    catch (e) { }
+                }
+                return logic;
+            });
+        }
+    }
+    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' }
+        });
+        if (response.data.result) {
+            details.variables = response.data.result;
+        }
+    }
+    catch (e) { }
+    // Get snapshots
+    try {
+        const response = await client.get(`/api/now/table/${FLOW_TABLES.SNAPSHOT}`, {
+            params: { sysparm_query: `flow=${flow.sys_id}`, sysparm_orderby: 'DESCsys_created_on', sysparm_limit: 5 }
+        });
+        if (response.data.result) {
+            details.snapshots = response.data.result;
+        }
+    }
+    catch (e) { }
+    // Build tree structure for nested actions
+    const buildTree = () => {
+        const tree = [];
+        const itemMap = new Map();
+        // Index all items
+        for (const action of details.actions) {
+            itemMap.set(action.sys_id, { ...action, _type: 'action', _children: [] });
+        }
+        for (const logic of details.logic) {
+            itemMap.set(logic.sys_id, { ...logic, _type: 'logic', _children: [] });
+        }
+        // Build hierarchy
+        itemMap.forEach((item, id) => {
+            if (item.parent_logic_instance) {
+                const parent = itemMap.get(item.parent_logic_instance);
+                if (parent) {
+                    parent._children.push(item);
+                }
+                else {
+                    tree.push(item);
+                }
+            }
+            else {
+                tree.push(item);
+            }
+        });
+        // Sort by order
+        const sortByOrder = (items) => {
+            items.sort((a, b) => (a.order || 0) - (b.order || 0));
+            for (const item of items) {
+                if (item._children && item._children.length > 0) {
+                    sortByOrder(item._children);
+                }
+            }
+        };
+        sortByOrder(tree);
+        return tree;
+    };
+    details.tree_structure = buildTree();
+    details.version_info = versionInfo;
+    return (0, error_handler_js_1.createSuccessResult)({
+        action: 'get_details',
+        ...details
+    });
+}
+/**
+ * Publish flow changes (create new snapshot and activate)
+ */
+async function handlePublish(args, client, versionInfo) {
+    const { flow_id, flow_name } = args;
+    const flow = await findFlow(client, flow_id, flow_name);
+    if (!flow) {
+        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
+    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)
+    };
+    try {
+        await client.post(`/api/now/table/${FLOW_TABLES.SNAPSHOT}`, snapshotData);
+    }
+    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
+    try {
+        await client.patch(`/api/now/table/${FLOW_TABLES.FLOW}/${flow.sys_id}`, {
+            active: true,
+            status: 'published',
+            main_snapshot: snapshotSysId,
+            latest_snapshot: snapshotSysId
+        });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(`Failed to activate flow: ${error.response?.data?.error?.message || error.message}`);
+    }
+    return (0, error_handler_js_1.createSuccessResult)({
+        action: 'publish',
+        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
+        }
+    });
+}
+// ==================== MAIN EXECUTOR ====================
+async function execute(args, context) {
+    const { action } = args;
+    if (!action) {
+        return (0, error_handler_js_1.createErrorResult)('action is required');
+    }
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        const versionInfo = await detectVersion(client);
+        console.log(`Executing flow management action: ${action}`);
+        console.log(`Detected version: ${versionInfo.version}, compression: ${versionInfo.useCompression}`);
+        switch (action) {
+            case 'create':
+                return handleCreate(args, client, versionInfo);
+            case 'update':
+                return handleUpdate(args, client, versionInfo);
+            case 'delete':
+                return handleDelete(args, client, versionInfo);
+            case 'clone':
+                return handleClone(args, client, versionInfo);
+            case 'activate':
+                return handleActivate(args, client);
+            case 'deactivate':
+                return handleDeactivate(args, client);
+            case 'add_action':
+                return handleAddAction(args, client, versionInfo);
+            case 'remove_action':
+                return handleRemoveAction(args, client, versionInfo);
+            case 'add_condition':
+                return handleAddCondition(args, client, versionInfo);
+            case 'add_loop':
+                return handleAddLoop(args, client, versionInfo);
+            case 'add_variable':
+                return handleAddVariable(args, client);
+            case 'get_details':
+                return handleGetDetails(args, client, versionInfo);
+            case 'publish':
+                return handlePublish(args, client, versionInfo);
+            default:
+                return (0, error_handler_js_1.createErrorResult)(`Unknown action: ${action}`);
+        }
+    }
+    catch (error) {
+        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)';
+//# sourceMappingURL=snow_manage_flow.js.map