powr-sdk-api 4.1.9 → 4.1.10

package/dist/index.js

@@ -16,7 +16,8 @@ const {
 const {
   createPowrRoutes,
   initializeFunctions,
-  initializeTools
+  initializeTools,
+  initializeScheduledTasks
 } = require("./routes");
 const {
   verifyToken
@@ -30,5 +31,6 @@ module.exports = {
   createPowrRoutes,
   initializeFunctions,
   initializeTools,
+  initializeScheduledTasks,
   verifyToken
 };

package/dist/routes/index.js

@@ -9,6 +9,7 @@ const {
 } = require('../middleware/jwtToken');
 const functionsManager = require('../services/functions');
 const toolsManager = require('../services/tools');
+const scheduledTasksManager = require('../services/scheduledTasks');
 
 // Import all route modules
 const commentsRoutes = require('./comments');
@@ -28,6 +29,7 @@ const profilesRoutes = require('./profiles');
 const chatRoutes = require('./chat');
 const feedsRoutes = require('./feeds');
 const toolsRoutes = require('./tools');
+const scheduledTasksRoutes = require('./scheduledTasks');
 
 // Synchronous router creation
 const createPowrRoutes = (options = {}) => {
@@ -52,6 +54,7 @@ const createPowrRoutes = (options = {}) => {
   router.use('/chat', verifyToken, chatRoutes);
   router.use('/feeds', verifyToken, feedsRoutes);
   router.use('/tools', verifyToken, toolsRoutes);
+  router.use('/scheduled-tasks', verifyToken, scheduledTasksRoutes);
   return router;
 };
 
@@ -66,8 +69,15 @@ const initializeTools = async (options = {}) => {
   // Initialize Tools manager with options
   await toolsManager.initialize(options);
 };
+
+// Async Scheduled Tasks initialization function
+const initializeScheduledTasks = async (options = {}) => {
+  // Initialize Scheduled Tasks manager with options
+  await scheduledTasksManager.initialize(options);
+};
 module.exports = {
   createPowrRoutes,
   initializeFunctions,
-  initializeTools
+  initializeTools,
+  initializeScheduledTasks
 };

package/dist/routes/scheduledTasks.js

@@ -0,0 +1,240 @@
+"use strict";
+
+const express = require('express');
+const router = express.Router();
+const scheduledTasksManager = require('../services/scheduledTasks');
+const toolsManager = require('../services/tools');
+
+// GET /scheduled-tasks - Get all tasks for user
+router.get('/', async (req, res) => {
+  try {
+    const isAdmin = req.user.role === 'admin';
+    const result = await scheduledTasksManager.getUserTasks(req.user.powrId, req.projectId, isAdmin);
+    res.json(result);
+  } catch (error) {
+    console.error('❌ Error getting scheduled tasks:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Failed to get scheduled tasks'
+    });
+  }
+});
+
+// GET /scheduled-tasks/:taskId - Get specific task
+router.get('/:taskId', async (req, res) => {
+  try {
+    const isAdmin = req.user.role === 'admin';
+    const result = await scheduledTasksManager.getTask(req.params.taskId, req.user.powrId, req.projectId, isAdmin);
+    if (!result.success) {
+      return res.status(404).json(result);
+    }
+    res.json(result);
+  } catch (error) {
+    console.error('❌ Error getting scheduled task:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Failed to get scheduled task'
+    });
+  }
+});
+
+// POST /scheduled-tasks - Create new task
+router.post('/', async (req, res) => {
+  try {
+    var _tool$actions;
+    const {
+      name,
+      description,
+      cronExpression,
+      toolId,
+      actionId,
+      params,
+      isActive
+    } = req.body;
+
+    // Validate required fields
+    if (!name || !cronExpression || !toolId || !actionId) {
+      return res.status(400).json({
+        success: false,
+        message: 'Missing required fields: name, cronExpression, toolId, actionId'
+      });
+    }
+
+    // Validate tool exists
+    const tool = toolsManager.getTool(toolId);
+    if (!tool) {
+      return res.status(400).json({
+        success: false,
+        message: `Tool not found: ${toolId}`
+      });
+    }
+
+    // Validate action exists
+    const action = (_tool$actions = tool.actions) === null || _tool$actions === void 0 ? void 0 : _tool$actions.find(a => a.id === actionId);
+    if (!action) {
+      return res.status(400).json({
+        success: false,
+        message: `Action not found: ${actionId} for tool ${toolId}`
+      });
+    }
+    const taskData = {
+      name,
+      description,
+      cronExpression,
+      toolId,
+      actionId,
+      params: params || {},
+      userId: req.user.powrId,
+      projectId: req.projectId,
+      // Add projectId
+      isActive: isActive !== false // Default to true
+    };
+    const result = await scheduledTasksManager.createTask(taskData);
+    res.status(201).json(result);
+  } catch (error) {
+    console.error('❌ Error creating scheduled task:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Failed to create scheduled task'
+    });
+  }
+});
+
+// PUT /scheduled-tasks/:taskId - Update task
+router.put('/:taskId', async (req, res) => {
+  try {
+    const {
+      name,
+      description,
+      cronExpression,
+      toolId,
+      actionId,
+      params,
+      isActive
+    } = req.body;
+
+    // Validate tool exists if toolId is being updated
+    if (toolId) {
+      const tool = toolsManager.getTool(toolId);
+      if (!tool) {
+        return res.status(400).json({
+          success: false,
+          message: `Tool not found: ${toolId}`
+        });
+      }
+
+      // Validate action exists if actionId is being updated
+      if (actionId) {
+        var _tool$actions2;
+        const action = (_tool$actions2 = tool.actions) === null || _tool$actions2 === void 0 ? void 0 : _tool$actions2.find(a => a.id === actionId);
+        if (!action) {
+          return res.status(400).json({
+            success: false,
+            message: `Action not found: ${actionId} for tool ${toolId}`
+          });
+        }
+      }
+    }
+    const updates = {};
+    if (name !== undefined) updates.name = name;
+    if (description !== undefined) updates.description = description;
+    if (cronExpression !== undefined) updates.cronExpression = cronExpression;
+    if (toolId !== undefined) updates.toolId = toolId;
+    if (actionId !== undefined) updates.actionId = actionId;
+    if (params !== undefined) updates.params = params;
+    if (isActive !== undefined) updates.isActive = isActive;
+    const isAdmin = req.user.role === 'admin';
+    const result = await scheduledTasksManager.updateTask(req.params.taskId, req.user.powrId, req.projectId, updates, isAdmin);
+    if (!result.success) {
+      return res.status(404).json(result);
+    }
+    res.json(result);
+  } catch (error) {
+    console.error('❌ Error updating scheduled task:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Failed to update scheduled task'
+    });
+  }
+});
+
+// DELETE /scheduled-tasks/:taskId - Delete task
+router.delete('/:taskId', async (req, res) => {
+  try {
+    const isAdmin = req.user.role === 'admin';
+    const result = await scheduledTasksManager.deleteTask(req.params.taskId, req.user.powrId, req.projectId, isAdmin);
+    if (!result.success) {
+      return res.status(404).json(result);
+    }
+    res.json(result);
+  } catch (error) {
+    console.error('❌ Error deleting scheduled task:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Failed to delete scheduled task'
+    });
+  }
+});
+
+// POST /scheduled-tasks/:taskId/toggle - Toggle task active status
+router.post('/:taskId/toggle', async (req, res) => {
+  try {
+    const {
+      isActive
+    } = req.body;
+    if (typeof isActive !== 'boolean') {
+      return res.status(400).json({
+        success: false,
+        message: 'isActive must be a boolean value'
+      });
+    }
+    const isAdmin = req.user.role === 'admin';
+    const result = await scheduledTasksManager.toggleTask(req.params.taskId, req.user.powrId, req.projectId, isActive, isAdmin);
+    if (!result.success) {
+      return res.status(404).json(result);
+    }
+    res.json(result);
+  } catch (error) {
+    console.error('❌ Error toggling scheduled task:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Failed to toggle scheduled task'
+    });
+  }
+});
+
+// POST /scheduled-tasks/:taskId/execute - Execute task manually
+router.post('/:taskId/execute', async (req, res) => {
+  try {
+    const isAdmin = req.user.role === 'admin';
+    const result = await scheduledTasksManager.executeTask(req.params.taskId, req.user.powrId, req.projectId, isAdmin);
+    if (!result.success) {
+      return res.status(404).json(result);
+    }
+    res.json(result);
+  } catch (error) {
+    console.error('❌ Error executing scheduled task:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Failed to execute scheduled task'
+    });
+  }
+});
+
+// GET /scheduled-tasks/stats - Get scheduler statistics
+router.get('/stats', async (req, res) => {
+  try {
+    const stats = scheduledTasksManager.getStats();
+    res.json({
+      success: true,
+      stats
+    });
+  } catch (error) {
+    console.error('❌ Error getting scheduler stats:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Failed to get scheduler stats'
+    });
+  }
+});
+module.exports = router;

package/dist/services/scheduledTasks.js

@@ -0,0 +1,459 @@
+"use strict";
+
+const {
+  getDb
+} = require("./mongo");
+const cron = require('node-cron');
+class ScheduledTasksManager {
+  constructor() {
+    this.scheduledJobs = new Map();
+    this.isInitialized = false;
+  }
+  async initialize() {
+    try {
+      console.log("📅 Initializing scheduled tasks manager...");
+
+      // Load existing tasks from database
+      const db = await getDb();
+      const tasks = await db.collection("scheduled_tasks").find({
+        isActive: true
+      }).toArray();
+
+      // Schedule existing active tasks
+      tasks.forEach(task => {
+        this.scheduleTask(task);
+      });
+      this.isInitialized = true;
+      console.log(`✅ Scheduled ${tasks.length} active tasks`);
+    } catch (error) {
+      console.error("❌ Failed to initialize scheduled tasks:", error);
+      this.isInitialized = true; // Still mark as initialized
+    }
+  }
+
+  // Create a new scheduled task
+  async createTask(taskData) {
+    try {
+      const db = await getDb();
+      const task = {
+        id: taskData.id || this.generateTaskId(),
+        name: taskData.name,
+        description: taskData.description,
+        cronExpression: taskData.cronExpression,
+        toolId: taskData.toolId,
+        actionId: taskData.actionId,
+        params: taskData.params,
+        userId: taskData.userId,
+        projectId: taskData.projectId,
+        // Add projectId
+        isActive: taskData.isActive !== false,
+        // Default to true
+        lastRun: null,
+        nextRun: this.getNextRunTime(taskData.cronExpression),
+        createdAt: new Date(),
+        updatedAt: new Date()
+      };
+      await db.collection("scheduled_tasks").insertOne(task);
+
+      // Schedule the task if it's active
+      if (task.isActive) {
+        this.scheduleTask(task);
+      }
+      console.log(`✅ Created scheduled task: ${task.name} (${task.id})`);
+      return {
+        success: true,
+        task
+      };
+    } catch (error) {
+      console.error("❌ Failed to create scheduled task:", error);
+      return {
+        success: false,
+        message: error.message
+      };
+    }
+  }
+
+  // Get all tasks for a user (filtered by projectId and userId)
+  async getUserTasks(userId, projectId, isAdmin = false) {
+    try {
+      const db = await getDb();
+
+      // Build query based on user role
+      let query = {};
+      if (isAdmin) {
+        // Admin sees all tasks in the project
+        query.projectId = projectId;
+      } else {
+        // Regular users see only their tasks in the project
+        query.userId = userId;
+        query.projectId = projectId;
+      }
+      const tasks = await db.collection("scheduled_tasks").find(query).sort({
+        createdAt: -1
+      }).toArray();
+      return {
+        success: true,
+        tasks
+      };
+    } catch (error) {
+      console.error("❌ Failed to get user tasks:", error);
+      return {
+        success: false,
+        message: error.message
+      };
+    }
+  }
+
+  // Get a specific task (with project and user validation)
+  async getTask(taskId, userId, projectId, isAdmin = false) {
+    try {
+      const db = await getDb();
+
+      // Build query based on user role
+      let query = {
+        id: taskId
+      };
+      if (isAdmin) {
+        // Admin can access any task in the project
+        query.projectId = projectId;
+      } else {
+        // Regular users can only access their own tasks
+        query.userId = userId;
+        query.projectId = projectId;
+      }
+      const task = await db.collection("scheduled_tasks").findOne(query);
+      if (!task) {
+        return {
+          success: false,
+          message: "Task not found"
+        };
+      }
+      return {
+        success: true,
+        task
+      };
+    } catch (error) {
+      console.error("❌ Failed to get task:", error);
+      return {
+        success: false,
+        message: error.message
+      };
+    }
+  }
+
+  // Update a task (with project and user validation)
+  async updateTask(taskId, userId, projectId, updates, isAdmin = false) {
+    try {
+      const db = await getDb();
+
+      // Build query based on user role
+      let query = {
+        id: taskId
+      };
+      if (isAdmin) {
+        // Admin can update any task in the project
+        query.projectId = projectId;
+      } else {
+        // Regular users can only update their own tasks
+        query.userId = userId;
+        query.projectId = projectId;
+      }
+
+      // Get existing task
+      const existingTask = await db.collection("scheduled_tasks").findOne(query);
+      if (!existingTask) {
+        return {
+          success: false,
+          message: "Task not found"
+        };
+      }
+
+      // Update fields
+      const updatedTask = {
+        ...existingTask,
+        ...updates,
+        updatedAt: new Date()
+      };
+
+      // Update next run time if cron expression changed
+      if (updates.cronExpression && updates.cronExpression !== existingTask.cronExpression) {
+        updatedTask.nextRun = this.getNextRunTime(updates.cronExpression);
+      }
+      await db.collection("scheduled_tasks").updateOne(query, {
+        $set: updatedTask
+      });
+
+      // Reschedule if active
+      if (updatedTask.isActive) {
+        this.unscheduleTask(taskId);
+        this.scheduleTask(updatedTask);
+      } else {
+        this.unscheduleTask(taskId);
+      }
+      console.log(`✅ Updated scheduled task: ${updatedTask.name} (${taskId})`);
+      return {
+        success: true,
+        task: updatedTask
+      };
+    } catch (error) {
+      console.error("❌ Failed to update scheduled task:", error);
+      return {
+        success: false,
+        message: error.message
+      };
+    }
+  }
+
+  // Delete a task (with project and user validation)
+  async deleteTask(taskId, userId, projectId, isAdmin = false) {
+    try {
+      const db = await getDb();
+
+      // Build query based on user role
+      let query = {
+        id: taskId
+      };
+      if (isAdmin) {
+        // Admin can delete any task in the project
+        query.projectId = projectId;
+      } else {
+        // Regular users can only delete their own tasks
+        query.userId = userId;
+        query.projectId = projectId;
+      }
+
+      // Get task to check if it exists
+      const task = await db.collection("scheduled_tasks").findOne(query);
+      if (!task) {
+        return {
+          success: false,
+          message: "Task not found"
+        };
+      }
+
+      // Remove from database
+      await db.collection("scheduled_tasks").deleteOne(query);
+
+      // Unschedule the task
+      this.unscheduleTask(taskId);
+      console.log(`✅ Deleted scheduled task: ${task.name} (${taskId})`);
+      return {
+        success: true
+      };
+    } catch (error) {
+      console.error("❌ Failed to delete scheduled task:", error);
+      return {
+        success: false,
+        message: error.message
+      };
+    }
+  }
+
+  // Toggle task active status (with project and user validation)
+  async toggleTask(taskId, userId, projectId, isActive, isAdmin = false) {
+    try {
+      const db = await getDb();
+
+      // Build query based on user role
+      let query = {
+        id: taskId
+      };
+      if (isAdmin) {
+        // Admin can toggle any task in the project
+        query.projectId = projectId;
+      } else {
+        // Regular users can only toggle their own tasks
+        query.userId = userId;
+        query.projectId = projectId;
+      }
+      const task = await db.collection("scheduled_tasks").findOne(query);
+      if (!task) {
+        return {
+          success: false,
+          message: "Task not found"
+        };
+      }
+      if (isActive) {
+        // Activate task
+        await db.collection("scheduled_tasks").updateOne(query, {
+          $set: {
+            isActive: true,
+            updatedAt: new Date()
+          }
+        });
+        this.scheduleTask({
+          ...task,
+          isActive: true
+        });
+      } else {
+        // Deactivate task
+        await db.collection("scheduled_tasks").updateOne(query, {
+          $set: {
+            isActive: false,
+            updatedAt: new Date()
+          }
+        });
+        this.unscheduleTask(taskId);
+      }
+      console.log(`${isActive ? '✅' : '❌'} Task ${taskId} ${isActive ? 'activated' : 'deactivated'}`);
+      return {
+        success: true
+      };
+    } catch (error) {
+      console.error("❌ Failed to toggle task:", error);
+      return {
+        success: false,
+        message: error.message
+      };
+    }
+  }
+
+  // Execute a task manually (with project and user validation)
+  async executeTask(taskId, userId, projectId, isAdmin = false) {
+    try {
+      const db = await getDb();
+
+      // Build query based on user role
+      let query = {
+        id: taskId
+      };
+      if (isAdmin) {
+        // Admin can execute any task in the project
+        query.projectId = projectId;
+      } else {
+        // Regular users can only execute their own tasks
+        query.userId = userId;
+        query.projectId = projectId;
+      }
+      const task = await db.collection("scheduled_tasks").findOne(query);
+      if (!task) {
+        return {
+          success: false,
+          message: "Task not found"
+        };
+      }
+      console.log(`🚀 Manually executing task: ${task.name} (${taskId})`);
+
+      // Execute the task
+      const result = await this.executeTaskAction(task);
+
+      // Update last run time
+      await db.collection("scheduled_tasks").updateOne(query, {
+        $set: {
+          lastRun: new Date()
+        }
+      });
+      return {
+        success: true,
+        result
+      };
+    } catch (error) {
+      console.error("❌ Failed to execute task:", error);
+      return {
+        success: false,
+        message: error.message
+      };
+    }
+  }
+
+  // Schedule a task
+  scheduleTask(task) {
+    try {
+      // Unschedule if already scheduled
+      this.unscheduleTask(task.id);
+
+      // Validate cron expression
+      if (!cron.validate(task.cronExpression)) {
+        console.error(`❌ Invalid cron expression for task ${task.id}: ${task.cronExpression}`);
+        return;
+      }
+
+      // Schedule the task
+      const job = cron.schedule(task.cronExpression, async () => {
+        console.log(`⏰ Executing scheduled task: ${task.name} (${task.id})`);
+        await this.executeTaskAction(task);
+      });
+      this.scheduledJobs.set(task.id, job);
+      console.log(`✅ Scheduled task: ${task.name} (${task.id})`);
+    } catch (error) {
+      console.error(`❌ Failed to schedule task ${task.id}:`, error);
+    }
+  }
+
+  // Unschedule a task
+  unscheduleTask(taskId) {
+    const job = this.scheduledJobs.get(taskId);
+    if (job) {
+      job.stop();
+      this.scheduledJobs.delete(taskId);
+      console.log(`🛑 Unscheduled task: ${taskId}`);
+    }
+  }
+
+  // Execute the actual task action
+  async executeTaskAction(task) {
+    try {
+      // Import tools manager
+      const toolsManager = require('./tools');
+
+      // Execute the tool action
+      const result = await toolsManager.executeToolAction(task.userId, task.toolId, task.actionId, task.params);
+
+      // Log execution
+      await this.logTaskExecution(task, result);
+      return result;
+    } catch (error) {
+      console.error(`❌ Task execution failed for ${task.id}:`, error);
+      return {
+        success: false,
+        message: error.message
+      };
+    }
+  }
+
+  // Log task execution
+  async logTaskExecution(task, result) {
+    try {
+      const db = await getDb();
+      await db.collection("task_executions").insertOne({
+        taskId: task.id,
+        userId: task.userId,
+        toolId: task.toolId,
+        actionId: task.actionId,
+        params: task.params,
+        result: result,
+        executedAt: new Date()
+      });
+    } catch (error) {
+      console.error("❌ Failed to log task execution:", error);
+    }
+  }
+
+  // Helper methods
+  generateTaskId() {
+    return `task_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+  getNextRunTime(cronExpression) {
+    try {
+      const parser = require('cron-parser');
+      const interval = parser.parseExpression(cronExpression);
+      return interval.next().toDate();
+    } catch (error) {
+      console.error("❌ Failed to parse cron expression:", error);
+      return null;
+    }
+  }
+
+  // Get statistics
+  getStats() {
+    return {
+      isInitialized: this.isInitialized,
+      activeJobs: this.scheduledJobs.size,
+      totalJobs: this.scheduledJobs.size
+    };
+  }
+}
+
+// Create and export singleton instance
+const scheduledTasksManager = new ScheduledTasksManager();
+module.exports = scheduledTasksManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "powr-sdk-api",
-  "version": "4.1.9",
+  "version": "4.1.10",
   "description": "Shared API core library for PowrStack projects",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -39,15 +39,17 @@
     "@aws-sdk/client-s3": "^3.787.0",
     "@google-cloud/storage": "^7.16.0",
     "axios": "^1.6.0",
+    "bcrypt": "^5.1.1",
+    "cron-parser": "^4.9.0",
     "express": "^4.18.2",
     "jsonwebtoken": "^9.0.2",
-    "swagger-jsdoc": "^6.2.8",
-    "swagger-ui-express": "^5.0.0",
-    "winston": "^3.17.0",
     "mongodb": "^6.3.0",
     "multer": "^1.4.5-lts.1",
-    "bcrypt": "^5.1.1",
-    "nodemailer": "^6.10.0"
+    "node-cron": "^3.0.3",
+    "nodemailer": "^6.10.0",
+    "swagger-jsdoc": "^6.2.8",
+    "swagger-ui-express": "^5.0.0",
+    "winston": "^3.17.0"
   },
   "devDependencies": {
     "@babel/cli": "^7.23.9",