powr-sdk-api/dist/routes/tasks.js

Shared API core library for PowrStack projects. Zero dependencies - works with Express, Next.js API routes, and other frameworks. All features are optional and install only what you need.

"use strict";

const express = require("express");
const router = express.Router();
const tasksManager = require("../managers/tasks");
const toolsManager = require("../managers/tools");

// GET /tasks - Get all tasks
router.get("/", async (req, res) => {
  try {
    const isAdmin = req.user.access === 100;
    const result = await tasksManager.getUserTasks(req.user.powrId, req.projectId, isAdmin);
    if (result.success) {
      return res.status(200).json({
        success: true,
        tasks: result.tasks
      });
    } else {
      return res.status(400).json({
        success: false,
        message: result.message
      });
    }
  } catch (error) {
    console.error("Error retrieving tasks:", error);
    return res.status(500).json({
      success: false,
      message: "Failed to retrieve tasks."
    });
  }
});

// GET /tasks/:taskId - Get specific task
router.get("/:taskId", async (req, res) => {
  try {
    const isAdmin = req.user.access === 100;
    const result = await tasksManager.getTask(req.params.taskId, req.user.powrId, req.projectId, isAdmin);
    if (result.success) {
      return res.status(200).json({
        success: true,
        task: result.task
      });
    } else {
      return res.status(404).json({
        success: false,
        message: result.message
      });
    }
  } catch (error) {
    console.error("Error retrieving task:", error);
    return res.status(500).json({
      success: false,
      message: "Failed to retrieve task."
    });
  }
});

// POST /tasks - Create new task
router.post("/", async (req, res) => {
  try {
    var _tool$actions;
    const {
      name,
      description,
      scheduledFor,
      toolId,
      actionId,
      params,
      isActive
    } = req.body;

    // Validate required fields
    if (!name || !toolId || !actionId) {
      return res.status(400).json({
        success: false,
        message: "Missing required fields: name, 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,
      scheduledFor,
      // null, timestamp, or cron expression
      toolId,
      actionId,
      params: params || {},
      userId: req.user.powrId,
      projectId: req.projectId,
      isActive: isActive !== false // Default to true
    };
    const result = await tasksManager.createTask(taskData);
    if (result.success) {
      res.status(201).json({
        success: true,
        message: "Task created successfully",
        task: result.task
      });
    } else {
      res.status(400).json({
        success: false,
        message: result.message
      });
    }
  } 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,
      scheduledFor,
      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 updateData = {};
    if (name !== undefined) updateData.name = name;
    if (description !== undefined) updateData.description = description;
    if (scheduledFor !== undefined) updateData.scheduledFor = scheduledFor;
    if (toolId !== undefined) updateData.toolId = toolId;
    if (actionId !== undefined) updateData.actionId = actionId;
    if (params !== undefined) updateData.params = params;
    if (isActive !== undefined) updateData.isActive = isActive;
    const isAdmin = req.user.access === 100;
    const result = await tasksManager.updateTask(req.params.taskId, req.user.powrId, req.projectId, updateData, isAdmin);
    if (result.success) {
      res.status(200).json({
        success: true,
        message: "Task updated successfully"
      });
    } else {
      res.status(400).json({
        success: false,
        message: result.message
      });
    }
  } catch (error) {
    console.error("❌ Error updating scheduled task:", error);
    res.status(500).json({
      success: false,
      message: "Failed to update scheduled task"
    });
  }
});

// POST /tasks/:taskId/execute - Execute task manually
router.post("/:taskId/execute", async (req, res) => {
  try {
    const taskId = req.params.taskId;
    const isAdmin = req.user.access === 100;
    const result = await tasksManager.executeTask(taskId, req.user.powrId, req.projectId, isAdmin);
    if (result.success) {
      res.json({
        success: true,
        message: "Task executed successfully",
        result: result.result
      });
    } else {
      res.status(400).json({
        success: false,
        message: result.message
      });
    }
  } catch (error) {
    console.error("❌ Error executing scheduled task:", error);
    res.status(500).json({
      success: false,
      message: "Failed to execute scheduled task"
    });
  }
});

// POST /tasks/:taskId/toggle - Toggle task active status
router.post("/:taskId/toggle", async (req, res) => {
  try {
    const taskId = req.params.taskId;
    const {
      isActive
    } = req.body;
    const isAdmin = req.user.access === 100;
    const result = await tasksManager.toggleTask(taskId, req.user.powrId, req.projectId, isActive, isAdmin);
    if (result.success) {
      res.json({
        success: true,
        message: `Task ${isActive ? 'activated' : 'deactivated'} successfully`
      });
    } else {
      res.status(400).json({
        success: false,
        message: result.message
      });
    }
  } catch (error) {
    console.error("❌ Error toggling scheduled task:", error);
    res.status(500).json({
      success: false,
      message: "Failed to toggle scheduled task"
    });
  }
});

// DELETE /tasks/:taskId - Delete task
router.delete("/:taskId", async (req, res) => {
  try {
    const taskId = req.params.taskId;
    const isAdmin = req.user.access === 100;
    const result = await tasksManager.deleteTask(taskId, req.user.powrId, req.projectId, isAdmin);
    if (result.success) {
      res.json({
        success: true,
        message: "Task deleted successfully"
      });
    } else {
      res.status(400).json({
        success: false,
        message: result.message
      });
    }
  } catch (error) {
    console.error("❌ Error deleting scheduled task:", error);
    res.status(500).json({
      success: false,
      message: "Failed to delete scheduled task"
    });
  }
});

// GET /tasks/:taskId/executions - Get execution history for a task
router.get("/:taskId/executions", async (req, res) => {
  try {
    const taskId = req.params.taskId;
    const isAdmin = req.user.access === 100;
    const result = await tasksManager.getTaskExecutions(taskId, req.user.powrId, req.projectId, isAdmin);
    if (result.success) {
      res.json({
        success: true,
        executions: result.executions
      });
    } else {
      res.status(400).json({
        success: false,
        message: result.message
      });
    }
  } catch (error) {
    console.error("❌ Error retrieving task executions:", error);
    res.status(500).json({
      success: false,
      message: "Failed to retrieve task executions"
    });
  }
});

// POST /tasks/execute-scheduled - Execute all scheduled tasks (called by Atlas)
router.post("/execute-scheduled", async (req, res) => {
  try {
    const projectId = req.projectId;
    console.log(`🔍 API: Executing scheduled tasks for project: ${projectId}`);

    // Execute all scheduled tasks for this project
    const result = await tasksManager.executeScheduledTasks({
      projectId
    });
    console.log(`✅ API: Scheduled tasks execution completed for project: ${projectId}`);
    res.json({
      success: true,
      message: "Scheduled tasks executed successfully",
      projectId: projectId,
      result: result
    });
  } catch (error) {
    console.error("❌ API: Error executing scheduled tasks:", error);
    res.status(500).json({
      success: false,
      message: "Failed to execute scheduled tasks",
      error: error.message
    });
  }
});
module.exports = router;