@flowuent-org/diagramming-core 1.3.10 → 1.4.0

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

@@ -1,1179 +0,0 @@
-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) {
-      // Create new object reference with deep clone of formData so React detects the change
-      const updatedData = {
-        ...node.data,
-        ...(node.data.formData ? { formData: { ...node.data.formData } } : {}),
-      };
-      this.onNodeUpdate(nodeId, updatedData);
-    }
-  }
-
-  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';
-        if (this.onNodeUpdate) {
-          // Create new object reference so React detects the change
-          this.onNodeUpdate(currentNode.id, { ...currentNode.data });
-        }
-
-        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();
-          if (this.onNodeUpdate) {
-            // Create new object reference so React detects the change
-            this.onNodeUpdate(currentNode.id, { ...currentNode.data });
-          }
-        } catch (error) {
-          (currentNode.data as Record<string, unknown>).status = 'Error';
-          (currentNode.data as Record<string, unknown>).lastRun =
-            new Date().toISOString();
-          if (this.onNodeUpdate) {
-            // Create new object reference so React detects the change
-            this.onNodeUpdate(currentNode.id, { ...currentNode.data });
-          }
-          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;
-  }
-}