@flowuent-org/diagramming-core 1.0.5

package/packages/diagrams/src/lib/utils/AutomationExecutionEngine.ts

@@ -0,0 +1,1162 @@
+import { Node, Edge } from '@xyflow/react';
+import {
+  AutomationNodeForm,
+  AutomationStartNodeForm,
+  AutomationApiNodeForm,
+  AutomationFormattingNodeForm,
+  AutomationSheetsNodeForm,
+  AutomationEndNodeForm,
+} from '../types/automation-node-data-types';
+import {
+  GoogleSheetsService,
+  SheetsExportOptions,
+} from '../services/GoogleSheetsService';
+import { SlackService } from '../services/SlackService';
+import { TwilioWhatsAppService } from '../services/TwilioWhatsAppService';
+
+export interface AutomationContext {
+  runId: string;
+  startTime: Date;
+  variables: Record<string, string | number | boolean | object | null>;
+  logs: AutomationLog[];
+}
+
+export interface AutomationLog {
+  timestamp: Date;
+  nodeId: string;
+  nodeType: string;
+  level: 'info' | 'warning' | 'error' | 'success';
+  message: string;
+  data?: string | number | boolean | object | null;
+}
+
+export interface AutomationResult {
+  success: boolean;
+  context: AutomationContext;
+  finalOutput?: string | number | boolean | object | null;
+  error?: string;
+}
+
+export class AutomationExecutionEngine {
+  private nodes: Node[];
+  private edges: Edge[];
+  private context: AutomationContext;
+  private onNodeUpdate?: (nodeId: string, updatedData: any) => void;
+  private onLog?: (log: AutomationLog) => void;
+
+  constructor(
+    nodes: Node[],
+    edges: Edge[],
+    onNodeUpdate?: (nodeId: string, updatedData: any) => void,
+    onLog?: (log: AutomationLog) => void,
+  ) {
+    this.nodes = nodes;
+    this.edges = edges;
+    this.onNodeUpdate = onNodeUpdate;
+    this.onLog = onLog;
+    this.context = {
+      runId: this.generateRunId(),
+      startTime: new Date(),
+      variables: {},
+      logs: [],
+    };
+  }
+
+  private generateRunId(): string {
+    return `run_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  private storeExecutionResult(
+    nodeId: string,
+    result: string | number | boolean | object | null,
+    success: boolean = true,
+    error?: string,
+    executionTime?: number,
+  ): void {
+    const node = this.nodes.find((n) => n.id === nodeId);
+    if (!node) return;
+
+    const executionResult = {
+      success,
+      data: result,
+      timestamp: new Date().toISOString(),
+      error,
+      executionTime,
+    };
+
+    // Update the node's formData with execution result
+    if (node.data.formData) {
+      (node.data.formData as any).executionResult = executionResult;
+    } else {
+      (node.data as any).executionResult = executionResult;
+    }
+
+    // Notify the parent component about the node update
+    if (this.onNodeUpdate) {
+      this.onNodeUpdate(nodeId, node.data);
+    }
+  }
+
+  private log(
+    level: AutomationLog['level'],
+    nodeId: string,
+    nodeType: string,
+    message: string,
+    data?: string | number | boolean | object | null,
+  ) {
+    const entry: AutomationLog = {
+      timestamp: new Date(),
+      nodeId,
+      nodeType,
+      level,
+      message,
+      data,
+    };
+    this.context.logs.push(entry);
+    if (this.onLog) {
+      try {
+        this.onLog(entry);
+      } catch {
+        // ignore UI callback errors
+      }
+    }
+  }
+
+  private getNextNodes(currentNodeId: string): Node[] {
+    const outgoingEdges = this.edges.filter(
+      (edge) => edge.source === currentNodeId,
+    );
+    const nextNodeIds = outgoingEdges.map((edge) => edge.target);
+    return this.nodes.filter((node) => nextNodeIds.includes(node.id));
+  }
+
+  private async executeStartNode(
+    node: Node,
+  ): Promise<{ runId: string; startTime: string }> {
+    const data = node.data;
+    this.log(
+      'info',
+      node.id,
+      'AutomationStartNode',
+      'Starting automation workflow',
+    );
+
+    // Set initial context variables
+    this.context.variables.runId = this.context.runId;
+    this.context.variables.startTime = this.context.startTime.toISOString();
+
+    const result = {
+      runId: this.context.runId,
+      startTime: this.context.startTime.toISOString(),
+    };
+
+    // Store the execution result in node data
+    this.storeExecutionResult(node.id, result, true);
+
+    return result;
+  }
+
+  private async executeApiNode(node: Node): Promise<object> {
+    const data = node.data;
+    const formData = (data.formData || data) as AutomationApiNodeForm;
+
+    this.log(
+      'info',
+      node.id,
+      'AutomationApiNode',
+      `Making ${formData.method} request to ${formData.url}`,
+    );
+
+    try {
+      const headers: Record<string, string> = {};
+      if (formData.headers && Array.isArray(formData.headers)) {
+        formData.headers.forEach((header) => {
+          if (header.enabled) {
+            headers[header.key] = header.value;
+          }
+        });
+      }
+
+      const queryParams = new URLSearchParams();
+      if (formData.queryParams && Array.isArray(formData.queryParams)) {
+        formData.queryParams.forEach((param) => {
+          if (param.enabled) {
+            queryParams.append(param.key, param.value);
+          }
+        });
+      }
+
+      const url = queryParams.toString()
+        ? `${formData.url}?${queryParams.toString()}`
+        : formData.url;
+
+      const requestOptions: RequestInit = {
+        method: formData.method,
+        headers,
+        signal: AbortSignal.timeout(formData.timeout || 30000),
+      };
+
+      if (
+        formData.body &&
+        (formData.method === 'POST' || formData.method === 'PUT')
+      ) {
+        requestOptions.body = formData.body;
+      }
+
+      const response = await fetch(url, requestOptions);
+
+      if (!response.ok) {
+        throw new Error(
+          `HTTP ${response.status}: ${response.statusText} - ${url}`,
+        );
+      }
+
+      const responseData = await response.json();
+      this.log(
+        'success',
+        node.id,
+        'AutomationApiNode',
+        'API call completed successfully',
+        responseData,
+      );
+
+      // Store the execution result in node data
+      this.storeExecutionResult(node.id, responseData, true);
+
+      return responseData;
+    } catch (error) {
+      let errorMessage = `API call failed: ${error}`;
+
+      if (error instanceof TypeError && error.message.includes('fetch')) {
+        errorMessage = `Network error: Unable to connect to ${formData.url}. This might be due to CORS restrictions or network connectivity issues.`;
+      }
+
+      this.log(
+        'error',
+        node.id,
+        'AutomationApiNode',
+        errorMessage,
+        error instanceof Error ? error.message : String(error),
+      );
+
+      // Store the error result in node data
+      this.storeExecutionResult(node.id, null, false, errorMessage);
+
+      throw new Error(errorMessage);
+    }
+  }
+
+  private async executeFormattingNode(
+    node: Node,
+    inputData: string | number | boolean | object | null,
+  ): Promise<string | number | boolean | object | null> {
+    const data = node.data;
+    const formData = (data.formData || data) as AutomationFormattingNodeForm;
+
+    this.log(
+      'info',
+      node.id,
+      'AutomationFormattingNode',
+      'Starting data formatting',
+    );
+
+    try {
+      if (formData.formattingType === 'ai-powered' && formData.aiFormatting) {
+        // AI-powered formatting
+        this.log('info', node.id, 'AutomationFormattingNode', 'AI thinking...');
+        const aiResponse = await this.callAiApi(
+          formData.aiFormatting,
+          inputData,
+        );
+        this.log(
+          'success',
+          node.id,
+          'AutomationFormattingNode',
+          'AI formatting completed',
+          aiResponse,
+        );
+
+        // Store the execution result in node data
+        this.storeExecutionResult(node.id, aiResponse, true);
+
+        return aiResponse;
+      } else {
+        // Basic formatting
+        const formattedData = this.basicFormatting(inputData, formData);
+        this.log(
+          'success',
+          node.id,
+          'AutomationFormattingNode',
+          'Basic formatting completed',
+          formattedData,
+        );
+
+        // Store the execution result in node data
+        this.storeExecutionResult(node.id, formattedData, true);
+
+        return formattedData;
+      }
+    } catch (error) {
+      this.log(
+        'error',
+        node.id,
+        'AutomationFormattingNode',
+        `Formatting failed: ${error}`,
+        error instanceof Error ? error.message : String(error),
+      );
+
+      // Store the error result in node data
+      this.storeExecutionResult(
+        node.id,
+        null,
+        false,
+        error instanceof Error ? error.message : String(error),
+      );
+
+      throw error;
+    }
+  }
+
+  private async callAiApi(
+    aiConfig: NonNullable<AutomationFormattingNodeForm['aiFormatting']>,
+    inputData: string | number | boolean | object | null,
+  ): Promise<string | number | boolean | object | null> {
+    // Validate API key is not a placeholder
+    if (
+      !aiConfig.apiKey ||
+      aiConfig.apiKey.includes('your-openai-api-key-here') ||
+      aiConfig.apiKey.length < 10
+    ) {
+      throw new Error('Invalid API key. Please provide a valid API key.');
+    }
+
+    // Additional validation for Gemini API key format
+    if (aiConfig.apiUrl.includes('generativelanguage.googleapis.com')) {
+      if (!aiConfig.apiKey.startsWith('AIza')) {
+        throw new Error(
+          'Invalid Gemini API key format. Gemini API keys should start with "AIza".',
+        );
+      }
+    }
+
+    const prompt = `${aiConfig.instruction}\n\nInput data: ${JSON.stringify(inputData)}`;
+
+    // Determine if this is Gemini API or OpenAI API based on URL
+    const isGeminiApi = aiConfig.apiUrl.includes(
+      'generativelanguage.googleapis.com',
+    );
+
+    let requestBody: any;
+    let headers: Record<string, string>;
+
+    if (isGeminiApi) {
+      // Gemini API format
+      headers = {
+        'Content-Type': 'application/json',
+        'X-goog-api-key': aiConfig.apiKey,
+      };
+
+      requestBody = {
+        contents: [
+          {
+            parts: [
+              {
+                text: `${aiConfig.systemPrompt || 'You are a data formatting assistant.'}\n\n${prompt}`,
+              },
+            ],
+          },
+        ],
+        generationConfig: {
+          temperature: aiConfig.temperature || 0.1,
+          maxOutputTokens: aiConfig.maxTokens || 1000,
+          responseMimeType: 'application/json',
+        },
+      };
+    } else {
+      // OpenAI API format
+      headers = {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${aiConfig.apiKey}`,
+      };
+
+      requestBody = {
+        model: aiConfig.model,
+        messages: [
+          {
+            role: 'system',
+            content:
+              aiConfig.systemPrompt || 'You are a data formatting assistant.',
+          },
+          {
+            role: 'user',
+            content: prompt,
+          },
+        ],
+        temperature: aiConfig.temperature || 0.1,
+        max_tokens: aiConfig.maxTokens || 1000,
+      };
+    }
+
+    const response = await fetch(aiConfig.apiUrl, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(requestBody),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(
+        `AI API call failed: ${response.status} ${response.statusText}. ${errorText}`,
+      );
+    }
+
+    const result = await response.json();
+
+    let content: string;
+
+    if (isGeminiApi) {
+      // Gemini API response format
+      if (
+        !result.candidates ||
+        !result.candidates[0] ||
+        !result.candidates[0].content ||
+        !result.candidates[0].content.parts
+      ) {
+        throw new Error('Invalid Gemini API response format');
+      }
+      content = result.candidates[0].content.parts[0].text;
+    } else {
+      // OpenAI API response format
+      if (!result.choices || !result.choices[0] || !result.choices[0].message) {
+        throw new Error('Invalid AI API response format');
+      }
+      content = result.choices[0].message.content;
+    }
+
+    // Try to parse as JSON, fallback to string if parsing fails
+    try {
+      return JSON.parse(content);
+    } catch {
+      return content;
+    }
+  }
+
+  private basicFormatting(
+    inputData: string | number | boolean | object | null,
+    config: AutomationFormattingNodeForm,
+  ): string | number | boolean | object | null {
+    // Basic data transformation logic
+    if (typeof inputData === 'string') {
+      return inputData.trim();
+    }
+
+    if (Array.isArray(inputData)) {
+      return inputData.map((item) => this.basicFormatting(item, config));
+    }
+
+    if (typeof inputData === 'object' && inputData !== null) {
+      const formatted: Record<string, unknown> = {};
+      Object.keys(inputData).forEach((key) => {
+        formatted[key] = this.basicFormatting(
+          (inputData as Record<string, unknown>)[key] as
+            | string
+            | number
+            | boolean
+            | object
+            | null,
+          config,
+        );
+      });
+      return formatted;
+    }
+
+    return inputData;
+  }
+
+  private async executeSheetsNode(
+    node: Node,
+    inputData: string | number | boolean | object | null,
+  ): Promise<string | number | boolean | object | null> {
+    const data = node.data;
+    const formData = (data.formData || data) as AutomationSheetsNodeForm;
+
+    this.log(
+      'info',
+      node.id,
+      'AutomationSheetsNode',
+      'Starting Google Sheets export',
+    );
+
+    try {
+      // Initialize/derive per-output-method statuses container
+      const outputStatuses: any = (data as any).outputStatuses || {};
+      // Only set Google Sheets status when exportFormat includes sheets
+      if (
+        formData.exportOptions?.exportFormat === 'sheets' ||
+        formData.exportOptions?.exportFormat === 'both'
+      ) {
+        outputStatuses.googleSheets = 'running';
+      }
+      // Gmail runs only if enabled
+      if (formData.exportOptions?.emailSendEnabled) {
+        outputStatuses.gmail = 'running';
+      }
+      // Slack runs only if enabled
+      if (formData.exportOptions?.slack?.enabled) {
+        outputStatuses.slack = 'running';
+      }
+      // WhatsApp runs only if enabled
+      if (formData.exportOptions?.whatsapp?.enabled) {
+        outputStatuses.whatsapp = 'running';
+      }
+      (data as any).outputStatuses = outputStatuses;
+      if (this.onNodeUpdate) this.onNodeUpdate(node.id, data);
+
+      const sheetsConfig = formData.sheetsConfig;
+      const dataMapping = formData.dataMapping;
+      const exportOptions = formData.exportOptions;
+      const wantsSheets =
+        exportOptions?.exportFormat === 'sheets' ||
+        exportOptions?.exportFormat === 'both';
+      const wantsExcel =
+        exportOptions?.exportFormat === 'excel' ||
+        exportOptions?.exportFormat === 'both';
+      const wantsGmail = Boolean(exportOptions?.emailSendEnabled);
+
+      const sheetsService = new GoogleSheetsService();
+      // Only perform Google auth/validation when Sheets or Gmail is in use
+      if (wantsSheets || wantsGmail) {
+        this.log(
+          'info',
+          node.id,
+          'AutomationSheetsNode',
+          'Authenticating with Google (Sheets/Gmail)...',
+        );
+        // If Gmail send is enabled and we're using OAuth client, request both scopes in one consent
+        try {
+          const creds: any = sheetsConfig?.credentials || {};
+          if (creds.type === 'oauth' && (creds.clientId || creds.oauthToken)) {
+            const neededScopes = [
+              'https://www.googleapis.com/auth/spreadsheets',
+            ];
+            if (exportOptions?.emailSendEnabled) {
+              neededScopes.push('https://www.googleapis.com/auth/gmail.send');
+            }
+            const existing = Array.isArray(creds.scopes) ? creds.scopes : [];
+            const union = Array.from(new Set([...existing, ...neededScopes]));
+            creds.scopes = union;
+            sheetsConfig.credentials = creds;
+          }
+        } catch {
+          // Non-fatal; initialization will still proceed with default scopes
+        }
+        const validation = sheetsService.validateConfig(sheetsConfig);
+        if (!validation.valid) {
+          throw new Error(
+            `Configuration validation failed: ${validation.errors.join(', ')}`,
+          );
+        }
+      }
+
+      // Prepare data for export (only when exporting to Sheets/Excel)
+      let exportData: any[] = [];
+      if (wantsSheets || wantsExcel) {
+        if (Array.isArray(inputData)) {
+          exportData = inputData;
+        } else if (inputData && typeof inputData === 'object') {
+          exportData = [inputData];
+        } else {
+          throw new Error('Invalid input data format for export');
+        }
+      }
+
+      // Initialize Google Sheets service only when using Sheets or Gmail
+      if (wantsSheets || wantsGmail) {
+        await sheetsService.initialize(sheetsConfig);
+        this.log(
+          'success',
+          node.id,
+          'AutomationSheetsNode',
+          'Authenticated with Google APIs (Sheets/Gmail)',
+        );
+      }
+
+      // Prepare export options
+      const sheetsExportOptions: SheetsExportOptions = {
+        emailRecipients: exportOptions.emailRecipients,
+        fileName: exportOptions.fileName,
+        exportFormat:
+          exportOptions.exportFormat === 'both'
+            ? 'sheets'
+            : exportOptions.exportFormat,
+        includeHeaders: exportOptions.includeHeaders,
+      };
+
+      let response: any = null;
+
+      // Export to Google Sheets
+      if (
+        exportOptions?.exportFormat === 'sheets' ||
+        exportOptions?.exportFormat === 'both'
+      ) {
+        this.log(
+          'info',
+          node.id,
+          'AutomationSheetsNode',
+          'Writing data to Google Sheets...',
+        );
+        response = await sheetsService.exportToSheets(
+          exportData,
+          sheetsConfig,
+          dataMapping,
+          sheetsExportOptions,
+        );
+
+        this.log(
+          'success',
+          node.id,
+          'AutomationSheetsNode',
+          `Successfully exported ${response.rowsAdded} rows to Google Sheets`,
+          response,
+        );
+        // Mark GS connected on success
+        outputStatuses.googleSheets = 'connected';
+        (data as any).outputStatuses = outputStatuses;
+        if (this.onNodeUpdate) this.onNodeUpdate(node.id, data);
+      }
+
+      // Export to Excel
+      if (
+        exportOptions.exportFormat === 'excel' ||
+        exportOptions.exportFormat === 'both'
+      ) {
+        this.log(
+          'info',
+          node.id,
+          'AutomationSheetsNode',
+          'Exporting data to Excel...',
+        );
+        const excelResponse = await sheetsService.exportToExcel(
+          exportData,
+          dataMapping,
+          sheetsExportOptions,
+        );
+
+        this.log(
+          'success',
+          node.id,
+          'AutomationSheetsNode',
+          `Successfully exported ${excelResponse.rowsAdded} rows to Excel`,
+          excelResponse,
+        );
+
+        // If we're doing both, merge the responses
+        if (exportOptions.exportFormat === 'both') {
+          response = {
+            ...response,
+            excelExport: excelResponse,
+            combinedSuccess: response.success && excelResponse.success,
+          };
+        } else {
+          response = excelResponse;
+        }
+      }
+
+      // Optional email send (via mailto fallback or Gmail API if implemented)
+      if (exportOptions.emailSendEnabled) {
+        const emailRecipients = exportOptions.emailRecipients || [];
+        if (emailRecipients.length > 0) {
+          this.log(
+            'info',
+            node.id,
+            'AutomationSheetsNode',
+            `Sending email to ${emailRecipients.length} recipient(s)...`,
+          );
+          const emailSent = await sheetsService.sendEmail({
+            from: exportOptions.emailSender,
+            to: emailRecipients,
+            subject: exportOptions.emailSubject || 'Automation Output',
+            message: exportOptions.emailMessage,
+            spreadsheetUrl:
+              exportOptions.includeSpreadsheetLink &&
+              (response as any)?.spreadsheetUrl
+                ? (response as any).spreadsheetUrl
+                : undefined,
+            // Note: attachExcel via Gmail requires Gmail scope and MIME building;
+            // mailto cannot attach files. This is a placeholder hook.
+            attachExcelBlob: undefined,
+            attachExcelFileName: sheetsExportOptions.fileName,
+            // Critical: disable UI fallback to ensure fully automated send
+            disableUiFallback: true,
+          });
+
+          if (emailSent) {
+            this.log(
+              'success',
+              node.id,
+              'AutomationSheetsNode',
+              `Email sent to ${emailRecipients.length} recipient(s)`,
+            );
+            outputStatuses.gmail = 'connected';
+          } else {
+            this.log(
+              'error',
+              node.id,
+              'AutomationSheetsNode',
+              'Email send failed (API)',
+            );
+            outputStatuses.gmail = 'failed';
+          }
+          (data as any).outputStatuses = outputStatuses;
+          if (this.onNodeUpdate) this.onNodeUpdate(node.id, data);
+        }
+      }
+
+      // Optional Slack send via webhook
+      if (exportOptions.slack?.enabled) {
+        const slackService = new SlackService();
+        const validation = slackService.validateConfig(exportOptions.slack);
+        if (!validation.valid) {
+          throw new Error(
+            `Slack configuration invalid: ${validation.errors.join(', ')}`,
+          );
+        }
+
+        // Build message text with simple token replacements
+        const template =
+          exportOptions.slack.messageTemplate ||
+          'Automation update for {{fileName}}';
+        const contextVars: Record<string, any> = {
+          fileName: exportOptions.fileName,
+          rowsAdded: (response as any)?.rowsAdded,
+          sheetName:
+            (response as any)?.sheetName || formData.sheetsConfig?.sheetName,
+        };
+        const messageText = template.replace(/\{\{(\w+)\}\}/g, (_, key) =>
+          key in contextVars ? String(contextVars[key]) : '',
+        );
+
+        // Prefer spreadsheetUrl from Sheets response if available and flag set
+        const spreadsheetUrl = exportOptions.slack.includeSpreadsheetLink
+          ? (response as any)?.spreadsheetUrl || undefined
+          : undefined;
+
+        const payload = slackService.buildPayload(
+          exportOptions.slack,
+          messageText,
+          inputData,
+          spreadsheetUrl,
+        );
+
+        try {
+          this.log(
+            'info',
+            node.id,
+            'AutomationSheetsNode',
+            `Sending Slack message to #${exportOptions.slack.channel}...`,
+          );
+          await slackService.sendMessage({
+            webhookUrl: exportOptions.slack.webhookUrl,
+            payload,
+          });
+          this.log(
+            'success',
+            node.id,
+            'AutomationSheetsNode',
+            `Slack message sent to #${exportOptions.slack.channel}`,
+          );
+          outputStatuses.slack = 'connected';
+          (data as any).outputStatuses = outputStatuses;
+          if (this.onNodeUpdate) this.onNodeUpdate(node.id, data);
+        } catch (slackErr) {
+          const msg =
+            slackErr instanceof Error ? slackErr.message : String(slackErr);
+          this.log(
+            'error',
+            node.id,
+            'AutomationSheetsNode',
+            `Slack send failed: ${msg}`,
+          );
+          // Do not fail the whole workflow due to Slack CORS; mark Slack as failed but continue
+          outputStatuses.slack = 'failed';
+          (data as any).outputStatuses = outputStatuses;
+          if (this.onNodeUpdate) this.onNodeUpdate(node.id, data);
+        }
+      }
+
+      // Optional WhatsApp send
+      if (exportOptions.whatsapp?.enabled) {
+        try {
+          this.log(
+            'info',
+            node.id,
+            'AutomationSheetsNode',
+            `Sending WhatsApp message to ${exportOptions.whatsapp.phoneNumber}...`,
+          );
+
+          // Build WhatsApp message with template replacements
+          const template =
+            exportOptions.whatsapp.messageTemplate ||
+            'Automation Result: {{fileName}} completed successfully. Rows processed: {{rowsAdded}}.';
+          const contextVars: Record<string, any> = {
+            fileName: exportOptions.fileName,
+            rowsAdded: (response as any)?.rowsAdded,
+            sheetName:
+              (response as any)?.sheetName || formData.sheetsConfig?.sheetName,
+            timestamp: new Date().toLocaleString(),
+          };
+          const messageText = template.replace(/\{\{(\w+)\}\}/g, (_, key) =>
+            key in contextVars ? String(contextVars[key]) : '',
+          );
+
+          // Create WhatsApp message with execution data
+          const whatsappMessage = `
+Automation Result:
+------------------
+${messageText}
+
+Execution Details:
+- Run ID: ${this.context.runId}
+- Start Time: ${this.context.startTime.toLocaleString()}
+- Status: Completed Successfully
+- Data: ${JSON.stringify(inputData, null, 2)}
+          `;
+
+          // Check if Twilio is configured
+          if (exportOptions.whatsapp.twilio?.enabled) {
+            // Use Twilio WhatsApp API
+            const twilioService = new TwilioWhatsAppService({
+              accountSid: exportOptions.whatsapp.twilio.accountSid,
+              authToken: exportOptions.whatsapp.twilio.authToken,
+              fromNumber: exportOptions.whatsapp.twilio.fromNumber,
+              isSandbox: exportOptions.whatsapp.twilio.isSandbox,
+            });
+
+            // Validate Twilio configuration
+            const validation = twilioService.validateConfig();
+            if (!validation.valid) {
+              throw new Error(
+                `Twilio configuration invalid: ${validation.errors.join(', ')}`,
+              );
+            }
+
+            // Send message via Twilio
+
+            const twilioResult = await twilioService.sendMessage({
+              to: exportOptions.whatsapp.phoneNumber,
+              message: whatsappMessage.trim(),
+              templateSid: exportOptions.whatsapp.twilio.templateSid,
+              templateVariables:
+                exportOptions.whatsapp.twilio.templateVariables,
+            });
+
+            if (twilioResult.success) {
+              this.log(
+                'success',
+                node.id,
+                'AutomationSheetsNode',
+                `WhatsApp message sent via Twilio (SID: ${twilioResult.messageSid})`,
+              );
+              outputStatuses.whatsapp = 'connected';
+            } else {
+              throw new Error(`Twilio send failed: ${twilioResult.error}`);
+            }
+          } else {
+            // Fallback to WhatsApp Web (existing behavior)
+            const encodedMsg = encodeURIComponent(whatsappMessage.trim());
+            const whatsappUrl = `https://wa.me/${exportOptions.whatsapp.phoneNumber}?text=${encodedMsg}`;
+
+            // Open WhatsApp in a new tab
+            window.open(whatsappUrl, '_blank');
+
+            this.log(
+              'success',
+              node.id,
+              'AutomationSheetsNode',
+              `WhatsApp message opened for ${exportOptions.whatsapp.phoneNumber}`,
+            );
+            outputStatuses.whatsapp = 'connected';
+          }
+
+          (data as any).outputStatuses = outputStatuses;
+          if (this.onNodeUpdate) this.onNodeUpdate(node.id, data);
+        } catch (whatsappErr) {
+          const msg =
+            whatsappErr instanceof Error
+              ? whatsappErr.message
+              : String(whatsappErr);
+          this.log(
+            'error',
+            node.id,
+            'AutomationSheetsNode',
+            `WhatsApp send failed: ${msg}`,
+          );
+          outputStatuses.whatsapp = 'failed';
+          (data as any).outputStatuses = outputStatuses;
+          if (this.onNodeUpdate) this.onNodeUpdate(node.id, data);
+        }
+      }
+
+      // Store the execution result in node data
+      this.storeExecutionResult(node.id, response, true);
+
+      return response;
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : 'Unknown error';
+      this.log(
+        'error',
+        node.id,
+        'AutomationSheetsNode',
+        `Google Sheets export failed: ${errorMessage}`,
+      );
+
+      // Mark failing outputs
+      const dataRef: any = node.data;
+      dataRef.outputStatuses = dataRef.outputStatuses || {};
+      // If config missing -> not-set should be turned failed on workflow failure
+      const sheetsCfg =
+        dataRef.formData?.sheetsConfig || dataRef.sheetsConfig || {};
+      const creds = sheetsCfg.credentials || {};
+      const gsHasRequired = Boolean(
+        (sheetsCfg.spreadsheetId || creds.clientId) &&
+          sheetsCfg.sheetName &&
+          creds.type,
+      );
+      dataRef.outputStatuses.googleSheets = gsHasRequired ? 'failed' : 'failed';
+
+      const ex = dataRef.formData?.exportOptions || dataRef.exportOptions || {};
+      const gmHasRequired = Boolean(
+        ex.emailSendEnabled &&
+          ex.emailSender &&
+          (ex.emailRecipients?.length || 0) > 0 &&
+          ex.emailSubject &&
+          ex.emailMessage,
+      );
+      if (ex.emailSendEnabled) {
+        dataRef.outputStatuses.gmail = gmHasRequired ? 'failed' : 'failed';
+      }
+
+      const sl = ex.slack || {};
+      const slackHasRequired = Boolean(
+        sl.enabled && sl.webhookUrl && sl.channel,
+      );
+      if (sl.enabled) {
+        dataRef.outputStatuses.slack = slackHasRequired ? 'failed' : 'failed';
+      }
+
+      const wa = ex.whatsapp || {};
+      const whatsappHasRequired = Boolean(wa.enabled && wa.phoneNumber);
+      if (wa.enabled) {
+        dataRef.outputStatuses.whatsapp = whatsappHasRequired
+          ? 'failed'
+          : 'failed';
+      }
+
+      if (this.onNodeUpdate) this.onNodeUpdate(node.id, dataRef);
+
+      // Store the execution result in node data
+      this.storeExecutionResult(node.id, null, false, errorMessage);
+
+      throw error;
+    }
+  }
+
+  private getNestedValue(obj: any, path: string): any {
+    return path.split('.').reduce((current, key) => current?.[key], obj);
+  }
+
+  private formatValueForSheets(value: any, dataType: string): any {
+    if (value === null || value === undefined) {
+      return '';
+    }
+
+    switch (dataType) {
+      case 'string':
+        return String(value);
+      case 'number':
+        return Number(value);
+      case 'date':
+        return new Date(value).toISOString();
+      case 'boolean':
+        return Boolean(value);
+      default:
+        return String(value);
+    }
+  }
+
+  private async executeEndNode(
+    node: Node,
+    inputData: string | number | boolean | object | null,
+  ): Promise<string | number | boolean | object | null> {
+    const data = node.data;
+    const formData = (data.formData || data) as AutomationEndNodeForm;
+
+    this.log(
+      'info',
+      node.id,
+      'AutomationEndNode',
+      'Workflow completed successfully',
+    );
+
+    // Handle different output types
+    switch (formData.outputType) {
+      case 'display':
+        this.log(
+          'info',
+          node.id,
+          'AutomationEndNode',
+          'Output displayed in UI',
+          inputData,
+        );
+        break;
+      case 'store':
+        this.log(
+          'info',
+          node.id,
+          'AutomationEndNode',
+          'Data stored to destination',
+          inputData,
+        );
+        break;
+      case 'send':
+        this.log(
+          'info',
+          node.id,
+          'AutomationEndNode',
+          'Data sent to destination',
+          inputData,
+        );
+        break;
+    }
+
+    // Store the execution result in node data
+    this.storeExecutionResult(node.id, inputData, true);
+
+    return inputData;
+  }
+
+  private async executeNode(
+    node: Node,
+    inputData?: string | number | boolean | object | null,
+  ): Promise<string | number | boolean | object | null> {
+    const nodeType = node.type;
+
+    switch (nodeType) {
+      case 'AutomationStartNode':
+        return await this.executeStartNode(node);
+      case 'AutomationApiNode':
+        return await this.executeApiNode(node);
+      case 'AutomationFormattingNode':
+        return await this.executeFormattingNode(node, inputData || null);
+      case 'AutomationSheetsNode':
+        return await this.executeSheetsNode(node, inputData || null);
+      case 'AutomationEndNode':
+        return await this.executeEndNode(node, inputData || null);
+      default:
+        throw new Error(`Unknown node type: ${nodeType}`);
+    }
+  }
+
+  public async executeWorkflow(): Promise<AutomationResult> {
+    try {
+      // Find start node
+      const startNode = this.nodes.find(
+        (node) => node.type === 'AutomationStartNode',
+      );
+      if (!startNode) {
+        throw new Error('No start node found in workflow');
+      }
+
+      this.log('info', 'workflow', 'engine', 'Starting workflow execution');
+
+      // Execute nodes in sequence
+      let currentNode: Node | null = startNode;
+      let currentData: string | number | boolean | object | null = null;
+      const visitedNodes = new Set<string>();
+
+      while (currentNode) {
+        if (visitedNodes.has(currentNode.id)) {
+          throw new Error(
+            `Circular dependency detected: node ${currentNode.id} already visited`,
+          );
+        }
+
+        visitedNodes.add(currentNode.id);
+
+        // Announce node execution start
+        this.log(
+          'info',
+          currentNode.id,
+          String(currentNode.type || 'node'),
+          'Executing node...',
+        );
+
+        // Update node status to running
+        (currentNode.data as Record<string, unknown>).status = 'Running';
+
+        try {
+          currentData = await this.executeNode(currentNode, currentData);
+          (currentNode.data as Record<string, unknown>).status = 'Completed';
+          (currentNode.data as Record<string, unknown>).lastRun =
+            new Date().toISOString();
+        } catch (error) {
+          (currentNode.data as Record<string, unknown>).status = 'Error';
+          (currentNode.data as Record<string, unknown>).lastRun =
+            new Date().toISOString();
+          throw error;
+        }
+
+        // Find next node
+        const nextNodes = this.getNextNodes(currentNode.id);
+        if (nextNodes.length > 0) {
+          const next = nextNodes[0];
+          this.log(
+            'info',
+            next.id,
+            String(next.type || 'node'),
+            'Moving to next node',
+          );
+          currentNode = next;
+        } else {
+          this.log('info', 'workflow', 'engine', 'No next node. Ending.');
+          currentNode = null;
+        }
+      }
+
+      this.log(
+        'success',
+        'workflow',
+        'engine',
+        'Workflow execution completed successfully',
+      );
+
+      return {
+        success: true,
+        context: this.context,
+        finalOutput: currentData,
+      };
+    } catch (error) {
+      this.log(
+        'error',
+        'workflow',
+        'engine',
+        `Workflow execution failed: ${error}`,
+      );
+
+      return {
+        success: false,
+        context: this.context,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  public getLogs(): AutomationLog[] {
+    return this.context.logs;
+  }
+
+  public getContext(): AutomationContext {
+    return this.context;
+  }
+}