powr-sdk-api 4.1.10 → 4.2.0

package/dist/middleware/projectId.js

@@ -11,7 +11,7 @@ const config = require('../config');
  */
 const injectProjectId = (options = {}) => {
   const isCentralService = options.isCentralService || false;
-  const excludePaths = options.excludePaths || ['/auth/login', '/auth/register', '/health'];
+  const excludePaths = options.excludePaths || ['/health'];
   return (req, res, next) => {
     try {
       // Skip validation for excluded paths

package/dist/routes/index.js

@@ -9,8 +9,6 @@ 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');
 const filesRoutes = require('./files');
@@ -29,7 +27,7 @@ const profilesRoutes = require('./profiles');
 const chatRoutes = require('./chat');
 const feedsRoutes = require('./feeds');
 const toolsRoutes = require('./tools');
-const scheduledTasksRoutes = require('./scheduledTasks');
+const tasksRoutes = require('./tasks');
 
 // Synchronous router creation
 const createPowrRoutes = (options = {}) => {
@@ -54,7 +52,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);
+  router.use('/tasks', verifyToken, tasksRoutes);
   return router;
 };
 
@@ -69,15 +67,8 @@ 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,
-  initializeScheduledTasks
+  initializeTools
 };

package/dist/routes/tasks.js

@@ -0,0 +1,183 @@
+"use strict";
+
+const express = require("express");
+const router = express.Router();
+const toolsManager = require("../services/tools");
+const {
+  getDb
+} = require("../services/mongo");
+
+// GET /tasks - Get all tasks
+router.get("/", async (req, res) => {
+  const projectId = req.projectId;
+  try {
+    const query = {
+      projectId
+    };
+    if (req.user.access !== 100) {
+      query.userId = req.user.powrId;
+    }
+    const db = await getDb();
+    const tasksData = await db.collection("tasks").find(query).toArray();
+    return res.status(200).json({
+      success: true,
+      tasks: tasksData
+    });
+  } catch (error) {
+    console.error("Error retrieving tasks entries:", error);
+    return res.status(500).json({
+      success: false,
+      message: "Failed to retrieve tasks entries."
+    });
+  }
+});
+
+// POST /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 || {},
+      projectId: req.projectId,
+      userId: req.user.access === 100 ? null : req.user.powrId,
+      isActive: isActive !== false,
+      // Default to true
+      createdAt: new Date(),
+      updatedAt: new Date()
+    };
+    const db = await getDb();
+    await db.collection("tasks").insertOne(taskData);
+    console.log(`✅ Created scheduled task: ${taskData.name}`);
+    res.status(201).json({
+      success: true,
+      message: "Task created successfully"
+    });
+  } catch (error) {
+    console.error("❌ Error creating scheduled task:", error);
+    res.status(500).json({
+      success: false,
+      message: "Failed to create scheduled task"
+    });
+  }
+});
+
+// PUT /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;
+
+    // Build query based on user role
+    let query = {
+      id: req.params.taskId
+    };
+    const db = await getDb();
+    // Get existing task
+    const existingTask = await db.collection("tasks").findOne(query);
+    if (!existingTask) {
+      return res.status(404).json({
+        success: false,
+        message: "Task not found"
+      });
+    }
+
+    // Update fields
+    const updatedTask = {
+      ...existingTask,
+      ...updates,
+      updatedAt: new Date()
+    };
+    await db.collection("tasks").updateOne(query, {
+      $set: updatedTask
+    });
+    res.status(200).json({
+      success: true,
+      message: "Task updated successfully"
+    });
+  } catch (error) {
+    console.error("❌ Error updating scheduled task:", error);
+    res.status(500).json({
+      success: false,
+      message: "Failed to update scheduled task"
+    });
+  }
+});
+module.exports = router;

package/dist/services/tasks.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.10",
+  "version": "4.2.0",
   "description": "Shared API core library for PowrStack projects",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",