feat(actions): Add file operations, compression, and storage integration

- Add FileInfo method to retrieve detailed file metadata (size, mode, modification time)
- Add ListDirectory method with pattern matching and recursive directory traversal support
- Add Compress method to create zip archives from multiple source paths
- Add Extract method to decompress zip files to destination directory
- Integrate Storage service into ActionService for persistent data management
- Update ActionService constructor to accept and store Storage dependency
- Add archive/zip import for compression/extraction functionality
- Clean up whitespace and formatting throughout file operations
- Enhance HTTP request handling with improved error messages and response parsing
- Improve shell command execution with better error handling and exit code tracking
- These changes enable workflow nodes to perform advanced file operations, manage archives, and persist data across executions

Author: OffLine911

actions.go

@@ -214,6 +214,99 @@ export class WorkflowExecutor {
         return output;
       }
 
+      if (nodeType === 'loop_parallel_foreach') {
+        const { items, itemVar, concurrency } = output;
+        const loopEdges = outgoing.filter(e => e.sourceHandle === 'loop');
+        const doneEdges = outgoing.filter(e => e.sourceHandle === 'done');
+        const limit = parseInt(concurrency) || 5;
+
+        if (Array.isArray(items)) {
+          this.onLog('info', `⚡ [Parallel] Processing ${items.length} items (concurrency: ${limit})`, nodeId);
+          
+          // Split items into chunks
+          for (let i = 0; i < items.length; i += limit) {
+            if (this.isAborted) break;
+            const chunk = items.slice(i, i + limit);
+            
+            await Promise.all(chunk.map(async (item, chunkIdx) => {
+              const idx = i + chunkIdx;
+              // Note: Variables might need isolation for parallel execution
+              // For now, we'll try a simple shared variable approach (warning: race conditions likely)
+              // In a robust implementation, each parallel branch should have local variables
+              this.variables[itemVar || 'item'] = item;
+              
+              const nodeLog = `⚡ [Parallel] Item ${idx + 1}/${items.length}`;
+              this.onLog('info', nodeLog, nodeId);
+
+              for (const edge of loopEdges) {
+                await this.executeNode(edge.target);
+              }
+            }));
+          }
+        }
+
+        for (const edge of doneEdges) {
+          await this.executeNode(edge.target);
+        }
+        return output;
+      }
+
+      // === 2. Handle Branching & Error Handling ===
+      if (nodeType === 'condition_try_catch') {
+        const tryEdges = outgoing.filter(e => e.sourceHandle === 'try');
+        const catchEdges = outgoing.filter(e => e.sourceHandle === 'catch');
+        
+        try {
+          for (const edge of tryEdges) {
+            await this.executeNode(edge.target);
+          }
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : String(error);
+          this.variables['error'] = errorMsg;
+          this.onLog('warn', `🛡️ Caught error: ${errorMsg}. Routing to catch branch.`, nodeId);
+          
+          for (const edge of catchEdges) {
+            await this.executeNode(edge.target);
+          }
+          
+          if (output?.continueOnError === false) {
+            throw error;
+          }
+        }
+        return output;
+      }
+
+      if (nodeType === 'condition_filter') {
+        const { matched, notMatched } = output;
+        
+        // Process match branch
+        if (matched && matched.length > 0) {
+          const matchEdges = outgoing.filter(e => e.sourceHandle === 'match');
+          // Temporarily set output to matched array for the downstream nodes
+          const originalOutput = this.variables['output'];
+          this.variables['output'] = matched;
+          
+          for (const edge of matchEdges) {
+            await this.executeNode(edge.target);
+          }
+          // Restore (optional, depends on desired flow behavior)
+          this.variables['output'] = originalOutput;
+        }
+        
+        // Process no-match branch
+        if (notMatched && notMatched.length > 0) {
+          const noMatchEdges = outgoing.filter(e => e.sourceHandle === 'nomatch');
+          const originalOutput = this.variables['output'];
+          this.variables['output'] = notMatched;
+          
+          for (const edge of noMatchEdges) {
+            await this.executeNode(edge.target);
+          }
+          this.variables['output'] = originalOutput;
+        }
+        return output;
+      }
+
       if (nodeType === 'condition_manual_approval') {
         const { title, message } = output;
         this.onLog('info', `⏳ Waiting for manual approval: ${title}`, nodeId);
@@ -250,7 +343,13 @@ export class WorkflowExecutor {
       }
 
       // === 2. Handle Conditional Branching ===
-      if (nodeType === 'condition_if') {
+      if (
+        nodeType === 'condition_if' || 
+        nodeType === 'condition_type_check' || 
+        nodeType === 'condition_is_empty' ||
+        nodeType === 'condition_date_compare' ||
+        nodeType === 'condition_array_contains'
+      ) {
         const branch = output === true ? 'true' : 'false';
         const branchEdges = outgoing.filter(e => e.sourceHandle === branch);
 

frontend/src/executor/WorkflowExecutor.ts

@@ -493,4 +493,173 @@ export const actionHandlers: Record<string, (ctx: HandlerContext) => Promise<any
 
     return { logged: true, message, level };
   },
+
+  // === NEW ACTIONS ===
+  action_file_list: async ({ data, onLog }) => {
+    const { path, pattern, recursive, include } = data;
+    onLog('info', `📁 Listing directory: ${path}`);
+    if (pattern && pattern !== '*') onLog('info', `   Filter: ${pattern}`);
+    
+    try {
+      const items = await ActionService.ListDirectory(path, pattern || '*', !!recursive);
+      
+      // Filter by include type
+      let filtered = items;
+      if (include === 'files') {
+        filtered = items.filter((item: any) => !item.isDir);
+      } else if (include === 'folders') {
+        filtered = items.filter((item: any) => item.isDir);
+      }
+      
+      onLog('success', `✓ Found ${filtered.length} items`);
+      return filtered;
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      onLog('error', `✗ Failed to list directory: ${errorMsg}`);
+      throw error;
+    }
+  },
+
+  action_csv_parse: async ({ data, onLog }) => {
+    const { csv, delimiter, headers } = data;
+    onLog('info', '📊 Parsing CSV...');
+    
+    try {
+      const rows = csv.split('\n').filter((line: string) => line.trim());
+      const delim = delimiter || ',';
+      
+      if (rows.length === 0) return [];
+      
+      if (!headers) {
+        const result = rows.map((row: string) => row.split(delim));
+        onLog('success', `✓ Parsed ${result.length} rows (no headers)`);
+        return result;
+      }
+      
+      const head = rows[0].split(delim).map((h: string) => h.trim());
+      const result = rows.slice(1).map((row: string) => {
+        const values = row.split(delim);
+        const obj: any = {};
+        head.forEach((h: string, i: number) => {
+          obj[h] = values[i]?.trim() || '';
+        });
+        return obj;
+      });
+      
+      onLog('success', `✓ Parsed ${result.length} rows with ${head.length} columns`);
+      return result;
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      onLog('error', `✗ Failed to parse CSV: ${errorMsg}`);
+      throw error;
+    }
+  },
+
+  action_csv_write: async ({ data, onLog }) => {
+    const { data: inputData, delimiter, headers } = data;
+    onLog('info', '📊 Writing CSV...');
+    
+    try {
+      let arr: any[];
+      try {
+        arr = typeof inputData === 'string' ? JSON.parse(inputData) : inputData;
+      } catch {
+        throw new Error('Input must be a valid JSON array');
+      }
+      
+      if (!Array.isArray(arr)) throw new Error('Data is not an array');
+      if (arr.length === 0) return '';
+      
+      const delim = delimiter || ',';
+      const keys = Object.keys(arr[0]);
+      let csv = '';
+      
+      if (headers) {
+        csv += keys.join(delim) + '\n';
+      }
+      
+      csv += arr.map((row: any) => {
+        return keys.map(key => {
+          const val = row[key];
+          if (val === null || val === undefined) return '';
+          const str = String(val);
+          if (str.includes(delim) || str.includes('\n') || str.includes('"')) {
+            return `"${str.replace(/"/g, '""')}"`;
+          }
+          return str;
+        }).join(delim);
+      }).join('\n');
+      
+      onLog('success', `✓ Generated CSV (${csv.length} chars)`);
+      return csv;
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      onLog('error', `✗ Failed to write CSV: ${errorMsg}`);
+      throw error;
+    }
+  },
+
+  action_file_info: async ({ data, onLog }) => {
+    const { path } = data;
+    onLog('info', `ℹ️ Getting info for: ${path}`);
+    
+    try {
+      const { FileInfo } = await import('../../wailsjs/go/main/ActionService');
+      const info = await FileInfo(path);
+      onLog('success', `✓ File info retrieved: ${info.size} bytes`);
+      return info;
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      onLog('error', `✗ Failed to get file info: ${errorMsg}`);
+      throw error;
+    }
+  },
+
+  action_zip_compress: async ({ data, onLog }) => {
+    const { sources, zipPath } = data;
+    onLog('info', `🗜️ Compressing to: ${zipPath}`);
+    
+    try {
+      let sourceList: string[];
+      if (typeof sources === 'string') {
+        try {
+          sourceList = JSON.parse(sources);
+          if (!Array.isArray(sourceList)) sourceList = sources.split('\n').map(s => s.trim()).filter(Boolean);
+        } catch {
+          sourceList = sources.split('\n').map(s => s.trim()).filter(Boolean);
+        }
+      } else if (Array.isArray(sources)) {
+        sourceList = sources;
+      } else {
+        throw new Error('Sources must be an array or line-separated string');
+      }
+
+      if (sourceList.length === 0) throw new Error('No source paths provided');
+
+      const { Compress } = await import('../../wailsjs/go/main/ActionService');
+      await Compress(sourceList, zipPath);
+      onLog('success', `✓ Created ZIP archive: ${zipPath}`);
+      return { success: true, path: zipPath };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      onLog('error', `✗ Failed to compress: ${errorMsg}`);
+      throw error;
+    }
+  },
+
+  action_zip_extract: async ({ data, onLog }) => {
+    const { zipPath, destination } = data;
+    onLog('info', `📂 Extracting ${zipPath} to ${destination}`);
+    
+    try {
+      const { Extract } = await import('../../wailsjs/go/main/ActionService');
+      await Extract(zipPath, destination);
+      onLog('success', `✓ Extracted archive to: ${destination}`);
+      return { success: true, destination };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      onLog('error', `✗ Failed to extract: ${errorMsg}`);
+      throw error;
+    }
+  },
 };

frontend/src/handlers/actions.ts

@@ -280,4 +280,67 @@ export const appHandlers: Record<string, (ctx: HandlerContext) => Promise<any>>
     const result = typeof response.json === 'object' ? response.json : JSON.parse(response.body);
     return { id: result.id, url: result.url, title: data.title };
   },
+
+  // === FORGEFLOW INTERNAL ===
+  app_settings_get: async ({ data, onLog }) => {
+    const { key } = data;
+    onLog('info', `⚙️  Get setting: ${key}`);
+    
+    try {
+      const ActionService = await import('../../wailsjs/go/main/ActionService');
+      const value = await ActionService.GetSetting(key);
+      onLog('success', `✓ Setting '${key}': ${value}`);
+      return value;
+    } catch (error) {
+      onLog('warn', `⚠️  Setting '${key}' not found or error: ${error}`);
+      return null;
+    }
+  },
+
+  app_settings_set: async ({ data, onLog }) => {
+    const { key, value } = data;
+    onLog('info', `⚙️  Set setting: ${key}`);
+    
+    try {
+      const ActionService = await import('../../wailsjs/go/main/ActionService');
+      await ActionService.SaveSetting(key, String(value));
+      onLog('success', `✓ Setting '${key}' updated`);
+      return { success: true, key };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      onLog('error', `✗ Failed to set setting: ${errorMsg}`);
+      throw error;
+    }
+  },
+
+  app_secret_get: async ({ data, onLog }) => {
+    const { key } = data;
+    onLog('info', `🔒 Get secret: ${key}`);
+    
+    try {
+      const ActionService = await import('../../wailsjs/go/main/ActionService');
+      const value = await ActionService.GetSecret(key);
+      onLog('success', `✓ Secret '${key}' retrieved`);
+      return value;
+    } catch (error) {
+      onLog('warn', `⚠️  Secret '${key}' not found or error: ${error}`);
+      return null;
+    }
+  },
+
+  app_secret_set: async ({ data, onLog }) => {
+    const { key, value } = data;
+    onLog('info', `🔒 Set secret: ${key}`);
+    
+    try {
+      const ActionService = await import('../../wailsjs/go/main/ActionService');
+      await ActionService.SaveSecret(key, String(value));
+      onLog('success', `✓ Secret '${key}' stored in vault`);
+      return { success: true, key };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      onLog('error', `✗ Failed to store secret: ${errorMsg}`);
+      throw error;
+    }
+  },
 };