snow-flow 1.3.25 → 1.3.28

package/dist/optimization/index.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * Optimization Module Exports
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CostOptimizationEngine = exports.FlowPerformanceOptimizer = void 0;
+var flow_performance_optimizer_js_1 = require("./flow-performance-optimizer.js");
+Object.defineProperty(exports, "FlowPerformanceOptimizer", { enumerable: true, get: function () { return flow_performance_optimizer_js_1.FlowPerformanceOptimizer; } });
+var cost_optimization_engine_js_1 = require("./cost-optimization-engine.js");
+Object.defineProperty(exports, "CostOptimizationEngine", { enumerable: true, get: function () { return cost_optimization_engine_js_1.CostOptimizationEngine; } });

package/dist/orchestration/flow-update-orchestrator.js

@@ -0,0 +1,648 @@
+"use strict";
+/**
+ * 🚀 Flow Update Orchestration with Smart Rollbacks
+ *
+ * Intelligent flow updating system that provides safe, reliable updates
+ * with automatic testing, validation, and rollback capabilities.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowUpdateOrchestrator = void 0;
+const logger_js_1 = require("../utils/logger.js");
+const xml_first_flow_generator_js_1 = require("../utils/xml-first-flow-generator.js");
+class FlowUpdateOrchestrator {
+    constructor(client, memory) {
+        this.activeUpdates = new Map();
+        this.logger = new logger_js_1.Logger('FlowUpdateOrchestrator');
+        this.client = client;
+        this.memory = memory;
+        this.xmlGenerator = new xml_first_flow_generator_js_1.XMLFirstFlowGenerator();
+    }
+    /**
+     * Plan a flow update with comprehensive analysis
+     */
+    async planFlowUpdate(flowId, newDefinition, options = {}) {
+        this.logger.info('📋 Planning flow update', { flowId, strategy: options.strategy });
+        try {
+            // Get current flow version
+            const currentFlow = await this.client.getFlow(flowId);
+            if (!currentFlow.success) {
+                throw new Error(`Failed to retrieve current flow: ${currentFlow.error}`);
+            }
+            const currentVersion = {
+                sys_id: currentFlow.data.sys_id,
+                name: currentFlow.data.name,
+                version: currentFlow.data.version || '1.0.0',
+                definition: currentFlow.data.definition,
+                created_at: new Date(currentFlow.data.sys_created_on),
+                created_by: currentFlow.data.sys_created_by,
+                status: 'active',
+                metadata: {
+                    changeLog: [],
+                    dependencies: await this.analyzeDependencies(currentFlow.data.definition)
+                }
+            };
+            // Create target version
+            const targetVersion = {
+                sys_id: flowId,
+                name: newDefinition.name,
+                version: this.generateNextVersion(currentVersion.version),
+                definition: newDefinition,
+                created_at: new Date(),
+                created_by: 'flow_orchestrator',
+                status: 'draft',
+                metadata: {
+                    changeLog: await this.generateChangeLog(currentVersion.definition, newDefinition),
+                    dependencies: await this.analyzeDependencies(newDefinition)
+                }
+            };
+            // Determine update strategy
+            const strategy = options.strategy || await this.recommendUpdateStrategy(currentVersion, targetVersion);
+            // Create validation steps
+            const validationSteps = await this.createValidationSteps(currentVersion, targetVersion, options.testingLevel || 'comprehensive');
+            // Create rollback plan
+            const rollbackPlan = await this.createRollbackPlan(currentVersion, targetVersion, strategy);
+            // Assess risk level
+            const riskLevel = await this.assessRiskLevel(currentVersion, targetVersion);
+            // Estimate downtime
+            const estimatedDowntime = this.estimateDowntime(strategy, validationSteps.length);
+            const updatePlan = {
+                flowId,
+                currentVersion,
+                targetVersion,
+                updateStrategy: strategy,
+                validationSteps,
+                rollbackPlan,
+                estimatedDowntime,
+                riskLevel
+            };
+            // Store plan for execution
+            await this.memory.store(`flow_update_plan_${flowId}`, updatePlan, 3600000); // 1 hour
+            this.logger.info('✅ Flow update plan created', {
+                flowId,
+                strategy,
+                riskLevel,
+                validationSteps: validationSteps.length,
+                estimatedDowntime
+            });
+            return updatePlan;
+        }
+        catch (error) {
+            this.logger.error('❌ Failed to plan flow update', error);
+            throw error;
+        }
+    }
+    /**
+     * Execute flow update with monitoring and automatic rollback
+     */
+    async executeFlowUpdate(planId, options = {}) {
+        this.logger.info('🚀 Executing flow update', { planId, options });
+        const startTime = Date.now();
+        try {
+            // Load plan
+            const plan = await this.memory.get(`flow_update_plan_${planId}`);
+            if (!plan) {
+                throw new Error(`Update plan not found: ${planId}`);
+            }
+            // Create execution context
+            const execution = new FlowUpdateExecution(plan, this.logger, this.client, this.memory);
+            this.activeUpdates.set(planId, execution);
+            // Execute update
+            const result = await execution.execute(options);
+            // Clean up
+            this.activeUpdates.delete(planId);
+            return result;
+        }
+        catch (error) {
+            this.logger.error('❌ Flow update execution failed', error);
+            // Attempt emergency rollback if execution exists
+            const execution = this.activeUpdates.get(planId);
+            if (execution) {
+                try {
+                    await execution.emergencyRollback();
+                }
+                catch (rollbackError) {
+                    this.logger.error('❌ Emergency rollback also failed', rollbackError);
+                }
+            }
+            throw error;
+        }
+    }
+    /**
+     * Monitor active updates
+     */
+    getActiveUpdates() {
+        return Array.from(this.activeUpdates.entries()).map(([planId, execution]) => ({
+            planId,
+            status: execution.getStatus(),
+            progress: execution.getProgress()
+        }));
+    }
+    /**
+     * Cancel an active update
+     */
+    async cancelUpdate(planId) {
+        const execution = this.activeUpdates.get(planId);
+        if (!execution) {
+            return false;
+        }
+        try {
+            await execution.cancel();
+            this.activeUpdates.delete(planId);
+            return true;
+        }
+        catch (error) {
+            this.logger.error('❌ Failed to cancel update', error);
+            return false;
+        }
+    }
+    /**
+     * Private helper methods
+     */
+    async analyzeDependencies(flowDefinition) {
+        const dependencies = [];
+        // Analyze activities for dependencies
+        for (const activity of flowDefinition.activities) {
+            if (activity.type === 'create_record' || activity.type === 'update_record') {
+                dependencies.push(`table:${activity.inputs.table}`);
+            }
+            if (activity.type === 'assign_subflow') {
+                dependencies.push(`subflow:${activity.inputs.subflow_id}`);
+            }
+            if (activity.type === 'rest_step') {
+                dependencies.push(`rest_message:${activity.inputs.rest_message}`);
+            }
+        }
+        return [...new Set(dependencies)]; // Remove duplicates
+    }
+    generateNextVersion(currentVersion) {
+        const parts = currentVersion.split('.');
+        const patch = parseInt(parts[2] || '0') + 1;
+        return `${parts[0] || '1'}.${parts[1] || '0'}.${patch}`;
+    }
+    async generateChangeLog(current, target) {
+        const changes = [];
+        // Name change
+        if (current.name !== target.name) {
+            changes.push(`Renamed from "${current.name}" to "${target.name}"`);
+        }
+        // Description change
+        if (current.description !== target.description) {
+            changes.push('Updated description');
+        }
+        // Activities comparison
+        const currentActivities = current.activities.map(a => a.name);
+        const targetActivities = target.activities.map(a => a.name);
+        const added = targetActivities.filter(a => !currentActivities.includes(a));
+        const removed = currentActivities.filter(a => !targetActivities.includes(a));
+        added.forEach(activity => changes.push(`Added activity: ${activity}`));
+        removed.forEach(activity => changes.push(`Removed activity: ${activity}`));
+        if (changes.length === 0) {
+            changes.push('Minor configuration updates');
+        }
+        return changes;
+    }
+    async recommendUpdateStrategy(current, target) {
+        const riskFactors = {
+            majorChanges: target.metadata.changeLog.length > 5,
+            dependencyChanges: target.metadata.dependencies.length !== current.metadata.dependencies.length,
+            structuralChanges: target.definition.activities.length !== current.definition.activities.length,
+            criticalFlow: current.name.toLowerCase().includes('critical') || current.name.toLowerCase().includes('production')
+        };
+        const riskScore = Object.values(riskFactors).filter(Boolean).length;
+        if (riskScore >= 3) {
+            return 'maintenance_window';
+        }
+        else if (riskScore >= 2) {
+            return 'blue_green';
+        }
+        else if (riskScore >= 1) {
+            return 'canary';
+        }
+        else {
+            return 'in_place';
+        }
+    }
+    async createValidationSteps(current, target, testingLevel) {
+        const steps = [
+            {
+                id: 'syntax_validation',
+                name: 'Syntax Validation',
+                type: 'syntax',
+                required: true,
+                autoFix: false,
+                estimatedTime: 5000,
+                validator: async (flow) => {
+                    return this.validateSyntax(flow);
+                }
+            },
+            {
+                id: 'dependency_check',
+                name: 'Dependency Check',
+                type: 'dependencies',
+                required: true,
+                autoFix: false,
+                estimatedTime: 10000,
+                validator: async (flow) => {
+                    return this.validateDependencies(flow);
+                }
+            },
+            {
+                id: 'permission_check',
+                name: 'Permission Validation',
+                type: 'permissions',
+                required: true,
+                autoFix: false,
+                estimatedTime: 8000,
+                validator: async (flow) => {
+                    return this.validatePermissions(flow);
+                }
+            }
+        ];
+        if (testingLevel === 'comprehensive' || testingLevel === 'full_integration') {
+            steps.push({
+                id: 'performance_test',
+                name: 'Performance Testing',
+                type: 'performance',
+                required: false,
+                autoFix: false,
+                estimatedTime: 30000,
+                validator: async (flow) => {
+                    return this.performanceTest(flow);
+                }
+            });
+        }
+        if (testingLevel === 'full_integration') {
+            steps.push({
+                id: 'integration_test',
+                name: 'Integration Testing',
+                type: 'integration',
+                required: false,
+                autoFix: false,
+                estimatedTime: 60000,
+                validator: async (flow) => {
+                    return this.integrationTest(flow);
+                }
+            });
+        }
+        return steps;
+    }
+    async createRollbackPlan(current, target, strategy) {
+        const rollbackSteps = [
+            {
+                order: 1,
+                action: 'Create backup',
+                description: 'Create complete backup of current flow version',
+                automated: true,
+                validationCheck: 'Verify backup integrity'
+            },
+            {
+                order: 2,
+                action: 'Restore previous version',
+                description: 'Restore flow to previous working version',
+                automated: true,
+                validationCheck: 'Verify flow is active and accessible'
+            },
+            {
+                order: 3,
+                action: 'Validate rollback',
+                description: 'Test that rollback was successful',
+                automated: true,
+                validationCheck: 'Execute test workflow to verify functionality'
+            }
+        ];
+        return {
+            strategy: 'version_revert',
+            backupLocation: `flow_backup_${current.sys_id}_${Date.now()}`,
+            rollbackSteps,
+            estimatedTime: 30000, // 30 seconds
+            dataImpact: 'minimal'
+        };
+    }
+    async assessRiskLevel(current, target) {
+        let riskScore = 0;
+        // Major structural changes
+        if (target.definition.activities.length !== current.definition.activities.length) {
+            riskScore += 2;
+        }
+        // Dependency changes
+        if (target.metadata.dependencies.length !== current.metadata.dependencies.length) {
+            riskScore += 1;
+        }
+        // Many changes
+        if (target.metadata.changeLog.length > 5) {
+            riskScore += 1;
+        }
+        // Critical flow indicators
+        if (current.name.toLowerCase().includes('critical') || current.name.toLowerCase().includes('production')) {
+            riskScore += 2;
+        }
+        if (riskScore >= 5)
+            return 'critical';
+        if (riskScore >= 3)
+            return 'high';
+        if (riskScore >= 2)
+            return 'medium';
+        return 'low';
+    }
+    estimateDowntime(strategy, validationSteps) {
+        const baseTime = {
+            'in_place': 10000, // 10 seconds
+            'blue_green': 5000, // 5 seconds
+            'canary': 30000, // 30 seconds
+            'maintenance_window': 0 // No downtime during maintenance
+        };
+        return baseTime[strategy] + (validationSteps * 2000);
+    }
+    // Validation methods
+    async validateSyntax(flow) {
+        const issues = [];
+        // Basic syntax checks
+        if (!flow.name || flow.name.trim().length === 0) {
+            issues.push({
+                severity: 'error',
+                message: 'Flow name is required',
+                autoFixable: false,
+                impact: 'Flow cannot be created without a name'
+            });
+        }
+        if (!flow.activities || flow.activities.length === 0) {
+            issues.push({
+                severity: 'error',
+                message: 'Flow must have at least one activity',
+                autoFixable: false,
+                impact: 'Empty flows are not functional'
+            });
+        }
+        // Activity validation
+        for (const activity of flow.activities) {
+            if (!activity.name) {
+                issues.push({
+                    severity: 'error',
+                    message: `Activity missing name`,
+                    location: `Activity ${activity.type}`,
+                    autoFixable: false,
+                    impact: 'Activities must have names for identification'
+                });
+            }
+            if (!activity.type) {
+                issues.push({
+                    severity: 'error',
+                    message: `Activity missing type`,
+                    location: activity.name,
+                    autoFixable: false,
+                    impact: 'Activity type determines functionality'
+                });
+            }
+        }
+        return {
+            passed: issues.filter(i => i.severity === 'error').length === 0,
+            issues,
+            autoFixApplied: false,
+            recommendations: issues.length === 0 ? ['Syntax validation passed'] : ['Fix syntax errors before proceeding']
+        };
+    }
+    async validateDependencies(flow) {
+        const issues = [];
+        // Check table dependencies
+        for (const activity of flow.activities) {
+            if ((activity.type === 'create_record' || activity.type === 'update_record') && activity.inputs.table) {
+                try {
+                    const tableExists = await this.client.checkTableExists(activity.inputs.table);
+                    if (!tableExists) {
+                        issues.push({
+                            severity: 'error',
+                            message: `Table '${activity.inputs.table}' does not exist`,
+                            location: activity.name,
+                            autoFixable: false,
+                            impact: 'Activity will fail at runtime'
+                        });
+                    }
+                }
+                catch (error) {
+                    issues.push({
+                        severity: 'warning',
+                        message: `Could not verify table '${activity.inputs.table}'`,
+                        location: activity.name,
+                        autoFixable: false,
+                        impact: 'May cause runtime errors'
+                    });
+                }
+            }
+        }
+        return {
+            passed: issues.filter(i => i.severity === 'error').length === 0,
+            issues,
+            autoFixApplied: false,
+            recommendations: ['All dependencies validated successfully']
+        };
+    }
+    async validatePermissions(flow) {
+        const issues = [];
+        // Basic permission checks
+        if (flow.run_as === 'system') {
+            issues.push({
+                severity: 'warning',
+                message: 'Flow runs as system - consider using user context for security',
+                autoFixable: true,
+                impact: 'Potential security risk'
+            });
+        }
+        return {
+            passed: true,
+            issues,
+            autoFixApplied: false,
+            recommendations: ['Permission validation completed']
+        };
+    }
+    async performanceTest(flow) {
+        const issues = [];
+        // Performance heuristics
+        if (flow.activities.length > 15) {
+            issues.push({
+                severity: 'warning',
+                message: 'Flow has many activities - may impact performance',
+                autoFixable: false,
+                impact: 'Longer execution times'
+            });
+        }
+        return {
+            passed: true,
+            issues,
+            autoFixApplied: false,
+            recommendations: ['Performance test completed']
+        };
+    }
+    async integrationTest(flow) {
+        const issues = [];
+        // Integration test placeholder
+        return {
+            passed: true,
+            issues,
+            autoFixApplied: false,
+            recommendations: ['Integration test completed']
+        };
+    }
+}
+exports.FlowUpdateOrchestrator = FlowUpdateOrchestrator;
+class FlowUpdateExecution {
+    constructor(plan, logger, client, memory) {
+        this.status = 'pending';
+        this.progress = 0;
+        this.plan = plan;
+        this.logger = logger;
+        this.client = client;
+        this.memory = memory;
+    }
+    async execute(options) {
+        this.status = 'running';
+        const startTime = Date.now();
+        try {
+            // Step 1: Create backup
+            this.progress = 10;
+            this.backupId = await this.createBackup();
+            // Step 2: Run validations
+            this.progress = 30;
+            const validationResults = await this.runValidations(options.skipValidation);
+            // Step 3: Execute update
+            this.progress = 60;
+            const updateResult = await this.executeUpdate(options.dryRun);
+            // Step 4: Post-update validation
+            this.progress = 80;
+            const testResults = await this.runPostUpdateTests();
+            // Step 5: Complete
+            this.progress = 100;
+            this.status = 'completed';
+            return {
+                success: true,
+                flowId: this.plan.flowId,
+                newVersion: this.plan.targetVersion.version,
+                executionTime: Date.now() - startTime,
+                rollbackPerformed: false,
+                validationResults,
+                testResults,
+                issues: [],
+                warnings: [],
+                metrics: {
+                    stepsCompleted: 5,
+                    totalSteps: 5,
+                    downtime: this.plan.estimatedDowntime
+                }
+            };
+        }
+        catch (error) {
+            this.status = 'failed';
+            this.logger.error('❌ Update execution failed, initiating rollback', error);
+            const rollbackPerformed = await this.performRollback();
+            return {
+                success: false,
+                flowId: this.plan.flowId,
+                executionTime: Date.now() - startTime,
+                rollbackPerformed,
+                validationResults: [],
+                testResults: [],
+                issues: [error instanceof Error ? error.message : String(error)],
+                warnings: [],
+                metrics: {
+                    stepsCompleted: Math.floor(this.progress / 20),
+                    totalSteps: 5,
+                    downtime: rollbackPerformed ? this.plan.estimatedDowntime * 2 : 0
+                }
+            };
+        }
+    }
+    async cancel() {
+        this.status = 'cancelled';
+        await this.performRollback();
+    }
+    async emergencyRollback() {
+        await this.performRollback();
+    }
+    getStatus() {
+        return this.status;
+    }
+    getProgress() {
+        return this.progress;
+    }
+    async createBackup() {
+        const backupId = `flow_backup_${this.plan.flowId}_${Date.now()}`;
+        await this.memory.store(backupId, this.plan.currentVersion, 86400000); // 24 hours
+        return backupId;
+    }
+    async runValidations(skip) {
+        if (skip) {
+            return [];
+        }
+        const results = [];
+        for (const step of this.plan.validationSteps) {
+            if (step.required || !skip) {
+                const result = await step.validator(this.plan.targetVersion.definition);
+                results.push(result);
+                if (!result.passed && step.required) {
+                    throw new Error(`Required validation failed: ${step.name}`);
+                }
+            }
+        }
+        return results;
+    }
+    async executeUpdate(dryRun) {
+        if (dryRun) {
+            this.logger.info('🔍 Dry run - skipping actual update');
+            return { success: true, message: 'Dry run completed' };
+        }
+        // Update the flow
+        const result = await this.client.updateFlow(this.plan.flowId, this.plan.targetVersion.definition);
+        if (!result.success) {
+            throw new Error(`Flow update failed: ${result.error}`);
+        }
+        return result;
+    }
+    async runPostUpdateTests() {
+        // Basic connectivity test
+        const testResults = [];
+        try {
+            const flow = await this.client.getFlow(this.plan.flowId);
+            testResults.push({
+                testName: 'Flow Accessibility Test',
+                passed: flow.success,
+                executionTime: 1000,
+                details: flow.success ? 'Flow is accessible' : 'Flow not accessible'
+            });
+        }
+        catch (error) {
+            testResults.push({
+                testName: 'Flow Accessibility Test',
+                passed: false,
+                executionTime: 1000,
+                details: `Test failed: ${error}`
+            });
+        }
+        return testResults;
+    }
+    async performRollback() {
+        try {
+            if (!this.backupId) {
+                this.logger.error('❌ No backup available for rollback');
+                return false;
+            }
+            this.logger.info('🔄 Performing rollback to previous version');
+            const backup = await this.memory.get(this.backupId);
+            if (!backup) {
+                throw new Error('Backup not found');
+            }
+            const result = await this.client.updateFlow(this.plan.flowId, backup.definition);
+            if (result.success) {
+                this.logger.info('✅ Rollback completed successfully');
+                return true;
+            }
+            else {
+                this.logger.error('❌ Rollback failed', result.error);
+                return false;
+            }
+        }
+        catch (error) {
+            this.logger.error('❌ Rollback operation failed', error);
+            return false;
+        }
+    }
+}
+exports.default = FlowUpdateOrchestrator;