powr-sdk-api 4.3.7 → 4.3.8

package/dist/managers/tasks.js

@@ -14,9 +14,8 @@ class TasksManager {
       const task = {
         name: taskData.name,
         description: taskData.description,
-        toolId: taskData.toolId,
-        actionId: taskData.actionId,
-        params: taskData.params,
+        type: taskData.type || 'task',
+        // 'task' or 'workflow'
         userId: taskData.userId,
         projectId: taskData.projectId,
         isActive: taskData.isActive !== false,
@@ -29,6 +28,19 @@ class TasksManager {
         updatedAt: new Date()
       };
 
+      // Handle single task vs workflow
+      if (task.type === 'task') {
+        // Single task - backward compatible
+        task.toolId = taskData.toolId;
+        task.actionId = taskData.actionId;
+        task.params = taskData.params;
+      } else if (task.type === 'workflow') {
+        // Workflow - new structure
+        task.steps = taskData.steps || [];
+        task.trigger = taskData.trigger || 'manual';
+        task.schedule = taskData.schedule || null;
+      }
+
       // Calculate nextRun based on scheduling type
       if (!task.scheduledFor) {
         // Immediate execution - run on next Atlas trigger
@@ -368,17 +380,153 @@ class TasksManager {
   // Execute the actual task action
   async executeTaskAction(task) {
     try {
-      // Import tools manager
-      const toolsManager = require('./tools');
+      if (task.type === 'workflow') {
+        // Execute workflow
+        return await this.executeWorkflow(task);
+      } else {
+        // Execute single task (backward compatible)
+        const toolsManager = require('./tools');
+        const result = await toolsManager.executeToolAction(task);
+        await this.logTaskExecution(task, result);
+        return result;
+      }
+    } catch (error) {
+      console.error(`❌ Task execution failed for ${task._id}:`, error);
+      return {
+        success: false,
+        message: error.message
+      };
+    }
+  }
+
+  // Execute workflow with multiple steps and conditions
+  async executeWorkflow(workflow) {
+    try {
+      console.log(`🔄 Executing workflow: ${workflow.name}`);
+      const results = [];
+      let workflowSuccess = true;
+      for (const step of workflow.steps) {
+        try {
+          console.log(`📋 Executing step: ${step.type} - ${step.toolId}/${step.actionId}`);
+          if (step.type === 'condition') {
+            // Execute condition step
+            const conditionResult = await this.executeConditionStep(step, workflow.userId);
+            results.push({
+              stepId: step.id,
+              type: 'condition',
+              success: conditionResult.success,
+              result: conditionResult,
+              conditionMet: conditionResult.conditionMet
+            });
+
+            // Store condition result for subsequent steps
+            step.result = conditionResult;
+          } else if (step.type === 'action') {
+            // Check if action should execute based on conditions
+            if (this.shouldExecuteAction(step, results)) {
+              const actionResult = await this.executeActionStep(step, workflow.userId);
+              results.push({
+                stepId: step.id,
+                type: 'action',
+                success: actionResult.success,
+                result: actionResult
+              });
+              if (!actionResult.success) {
+                workflowSuccess = false;
+              }
+            } else {
+              console.log(`⏭️ Skipping action step ${step.id} - condition not met`);
+              results.push({
+                stepId: step.id,
+                type: 'action',
+                success: true,
+                result: {
+                  message: 'Step skipped - condition not met'
+                },
+                skipped: true
+              });
+            }
+          }
+        } catch (error) {
+          console.error(`❌ Step execution failed: ${step.id}`, error);
+          results.push({
+            stepId: step.id,
+            type: step.type,
+            success: false,
+            error: error.message
+          });
+          workflowSuccess = false;
+        }
+      }
+
+      // Log workflow execution
+      await this.logWorkflowExecution(workflow, results);
+      return {
+        success: workflowSuccess,
+        workflowName: workflow.name,
+        stepsExecuted: results.length,
+        results: results
+      };
+    } catch (error) {
+      console.error(`❌ Workflow execution failed: ${workflow.name}`, error);
+      return {
+        success: false,
+        message: error.message
+      };
+    }
+  }
 
-      // Execute the tool action
-      const result = await toolsManager.executeToolAction(task);
+  // Execute a condition step (e.g., weather check)
+  async executeConditionStep(step, userId) {
+    try {
+      const toolsManager = require('./tools');
+      const result = await toolsManager.executeToolAction({
+        userId: userId,
+        toolId: step.toolId,
+        actionId: step.actionId,
+        params: step.params
+      });
+      if (result.success) {
+        var _result$data, _result$data2, _step$params;
+        // Extract condition result (e.g., weather condition)
+        const conditionValue = ((_result$data = result.data) === null || _result$data === void 0 ? void 0 : _result$data.currentWeather) || ((_result$data2 = result.data) === null || _result$data2 === void 0 ? void 0 : _result$data2.condition) || 'unknown';
+        const expectedValue = step.expectedResult || ((_step$params = step.params) === null || _step$params === void 0 ? void 0 : _step$params.condition) || 'rain';
+        const conditionMet = conditionValue.toLowerCase() === expectedValue.toLowerCase();
+        return {
+          success: true,
+          conditionMet: conditionMet,
+          actualValue: conditionValue,
+          expectedValue: expectedValue,
+          data: result.data
+        };
+      } else {
+        return {
+          success: false,
+          conditionMet: false,
+          error: result.message
+        };
+      }
+    } catch (error) {
+      return {
+        success: false,
+        conditionMet: false,
+        error: error.message
+      };
+    }
+  }
 
-      // Log execution
-      await this.logTaskExecution(task, result);
+  // Execute an action step (e.g., send email)
+  async executeActionStep(step, userId) {
+    try {
+      const toolsManager = require('./tools');
+      const result = await toolsManager.executeToolAction({
+        userId: userId,
+        toolId: step.toolId,
+        actionId: step.actionId,
+        params: step.params
+      });
       return result;
     } catch (error) {
-      console.error(`❌ Task execution failed for ${task.id}:`, error);
       return {
         success: false,
         message: error.message
@@ -386,13 +534,32 @@ class TasksManager {
     }
   }
 
+  // Check if action should execute based on conditions
+  shouldExecuteAction(step, previousResults) {
+    if (!step.condition) {
+      return true; // No condition, always execute
+    }
+
+    // Simple condition evaluation
+    // For now, support basic conditions like "step1 === true"
+    const condition = step.condition;
+    if (condition.includes('step1') && condition.includes('=== true')) {
+      const step1Result = previousResults.find(r => r.stepId === 'step1');
+      return step1Result && step1Result.conditionMet === true;
+    }
+
+    // Add more condition parsing as needed
+    return true; // Default to execute if condition parsing fails
+  }
+
   // Log task execution
   async logTaskExecution(task, result) {
     try {
       const db = await getDb();
       await db.collection("task_executions").insertOne({
-        taskId: task.id,
+        taskId: task._id || task.id,
         userId: task.userId,
+        type: task.type || 'task',
         toolId: task.toolId,
         actionId: task.actionId,
         params: task.params,
@@ -404,6 +571,23 @@ class TasksManager {
     }
   }
 
+  // Log workflow execution
+  async logWorkflowExecution(workflow, results) {
+    try {
+      const db = await getDb();
+      await db.collection("workflow_executions").insertOne({
+        workflowId: workflow._id,
+        workflowName: workflow.name,
+        userId: workflow.userId,
+        projectId: workflow.projectId,
+        results: results,
+        executedAt: new Date()
+      });
+    } catch (error) {
+      console.error("❌ Failed to log workflow execution:", error);
+    }
+  }
+
   // Check if a string is a valid timestamp
   isTimestamp(value) {
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "powr-sdk-api",
-  "version": "4.3.7",
+  "version": "4.3.8",
   "description": "Shared API core library for PowrStack projects",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",