@flowuent-org/diagramming-core 1.3.10 → 1.4.1

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

@@ -1,1179 +1,658 @@
-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;
-  }
-}
+import { Node, Edge } from '@xyflow/react';
+import {
+  AutomationNodeForm,
+  AutomationStartNodeForm,
+  AutomationApiNodeForm,
+  AutomationFormattingNodeForm,
+  AutomationEndNodeForm,
+} from '../types/automation-node-data-types';
+
+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 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 '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;
+  }
+}