powr-sdk-api/dist/routes/tools.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 toolsManager = require("../managers/tools");
const {
  getDb
} = require("../services/mongo");

// Get Tools status
router.get("/status", async (req, res) => {
  try {
    const stats = toolsManager.getStats();
    return res.status(200).json({
      success: true,
      data: {
        ...stats,
        message: stats.isEnabled ? "Tools is running" : "Tools is disabled"
      }
    });
  } catch (err) {
    console.error("Error getting Tools status:", err);
    return res.status(500).json({
      success: false,
      message: "Error getting Tools status"
    });
  }
});

// Enable Tools
router.post("/enable", async (req, res) => {
  try {
    toolsManager.enable();
    return res.status(200).json({
      success: true,
      message: "Tools enabled successfully",
      data: toolsManager.getStats()
    });
  } catch (err) {
    console.error("Error enabling Tools:", err);
    return res.status(500).json({
      success: false,
      message: "Error enabling Tools"
    });
  }
});

// Disable Tools
router.post("/disable", async (req, res) => {
  try {
    toolsManager.disable();
    return res.status(200).json({
      success: true,
      message: "Tools disabled successfully",
      data: toolsManager.getStats()
    });
  } catch (err) {
    console.error("Error disabling Tools:", err);
    return res.status(500).json({
      success: false,
      message: "Error disabling Tools"
    });
  }
});

// Toggle Tools
router.post("/toggle", async (req, res) => {
  try {
    const isEnabled = toolsManager.toggle();
    return res.status(200).json({
      success: true,
      message: isEnabled ? "Tools enabled" : "Tools disabled",
      data: toolsManager.getStats()
    });
  } catch (err) {
    console.error("Error toggling Tools:", err);
    return res.status(500).json({
      success: false,
      message: "Error toggling Tools"
    });
  }
});

// Get all available tools
router.get('/', async (req, res) => {
  console.log("🔧 Tools GET request received");
  console.log("👤 User from request:", JSON.stringify(req.user, null, 2));
  try {
    const tools = toolsManager.getAllTools();
    console.log("📋 Retrieved tools:", tools.length);
    return res.status(200).json({
      success: true,
      data: tools,
      total: tools.length
    });
  } catch (error) {
    console.error("Error retrieving tools:", error);
    return res.status(500).json({
      success: false,
      message: "Failed to retrieve tools."
    });
  }
});

// Get tool by ID
router.get('/:toolId', async (req, res) => {
  try {
    const {
      toolId
    } = req.params;
    const tool = toolsManager.getTool(toolId);
    if (!tool) {
      return res.status(404).json({
        success: false,
        message: "Tool not found"
      });
    }
    return res.status(200).json({
      success: true,
      data: tool
    });
  } catch (error) {
    console.error("Error retrieving tool:", error);
    return res.status(500).json({
      success: false,
      message: "Failed to retrieve tool."
    });
  }
});

// Get tools by category
router.get('/category/:category', async (req, res) => {
  try {
    const {
      category
    } = req.params;
    const tools = toolsManager.getToolsByCategory(category);
    return res.status(200).json({
      success: true,
      data: tools,
      category,
      total: tools.length
    });
  } catch (error) {
    console.error("Error retrieving tools by category:", error);
    return res.status(500).json({
      success: false,
      message: "Failed to retrieve tools by category."
    });
  }
});

// Configure tool for user
router.post('/:toolId/configure', async (req, res) => {
  try {
    var _req$user;
    const {
      toolId
    } = req.params;
    const {
      config
    } = req.body;
    const userId = (_req$user = req.user) === null || _req$user === void 0 ? void 0 : _req$user.powrId; // From JWT token

    if (!userId) {
      return res.status(401).json({
        success: false,
        message: "User not authenticated"
      });
    }
    if (!config) {
      return res.status(400).json({
        success: false,
        message: "Configuration is required"
      });
    }
    const result = await toolsManager.configureTool(userId, toolId, config);
    if (result.success) {
      return res.status(200).json(result);
    } else {
      return res.status(400).json(result);
    }
  } catch (error) {
    console.error("Error configuring tool:", error);
    return res.status(500).json({
      success: false,
      message: "Failed to configure tool."
    });
  }
});

// Execute tool action
router.post('/:toolId/execute', async (req, res) => {
  try {
    var _req$headers$authoriz;
    const {
      toolId
    } = req.params;
    const {
      actionId,
      params
    } = req.body;

    // Check for service-to-service authentication
    const apiKey = req.headers['x-api-key'] || ((_req$headers$authoriz = req.headers['authorization']) === null || _req$headers$authoriz === void 0 ? void 0 : _req$headers$authoriz.replace('Bearer ', ''));
    const isServiceCall = apiKey === process.env.POWR_SERVICE_API_KEY;
    let userId;
    if (isServiceCall) {
      // For service calls, use the userId from the task
      userId = req.headers['x-user-id'] || 'system';
    } else {
      var _req$user2;
      // For regular calls, use JWT token
      userId = (_req$user2 = req.user) === null || _req$user2 === void 0 ? void 0 : _req$user2.powrId;
      if (!userId) {
        return res.status(401).json({
          success: false,
          message: "User not authenticated"
        });
      }
    }
    if (!actionId) {
      return res.status(400).json({
        success: false,
        message: "Action ID is required"
      });
    }
    const result = await toolsManager.executeToolAction(userId, toolId, actionId, params || {});
    if (result.success) {
      return res.status(200).json(result);
    } else {
      return res.status(400).json(result);
    }
  } catch (error) {
    console.error("Error executing tool action:", error);
    return res.status(500).json({
      success: false,
      message: "Failed to execute tool action."
    });
  }
});

// Test tool connection
router.post('/:toolId/test', async (req, res) => {
  try {
    var _req$user3;
    const {
      toolId
    } = req.params;
    const userId = (_req$user3 = req.user) === null || _req$user3 === void 0 ? void 0 : _req$user3.powrId; // From JWT token

    if (!userId) {
      return res.status(401).json({
        success: false,
        message: "User not authenticated"
      });
    }
    const result = await toolsManager.testToolConnection(userId, toolId);
    if (result.success) {
      return res.status(200).json(result);
    } else {
      return res.status(400).json(result);
    }
  } catch (error) {
    console.error("Error testing tool connection:", error);
    return res.status(500).json({
      success: false,
      message: "Failed to test tool connection."
    });
  }
});

// Get user's configured tools
router.get('/user/configured', async (req, res) => {
  try {
    var _req$user4;
    const userId = (_req$user4 = req.user) === null || _req$user4 === void 0 ? void 0 : _req$user4.powrId; // From JWT token

    if (!userId) {
      return res.status(401).json({
        success: false,
        message: "User not authenticated"
      });
    }
    const userTools = await toolsManager.getUserTools(userId);

    // Enrich with tool details
    const enrichedUserTools = userTools.map(userTool => {
      const tool = toolsManager.getTool(userTool.toolId);
      return {
        ...userTool,
        tool: tool ? {
          id: tool.id,
          name: tool.name,
          description: tool.description,
          category: tool.category,
          icon: tool.icon,
          version: tool.version,
          actions: tool.actions
        } : null
      };
    });
    return res.status(200).json({
      success: true,
      data: enrichedUserTools,
      total: enrichedUserTools.length
    });
  } catch (error) {
    console.error("Error retrieving user tools:", error);
    return res.status(500).json({
      success: false,
      message: "Failed to retrieve user tools."
    });
  }
});

// Toggle tool for user
router.post('/user/:toolId/toggle', async (req, res) => {
  try {
    var _req$user5;
    const {
      toolId
    } = req.params;
    const {
      enabled
    } = req.body;
    const userId = (_req$user5 = req.user) === null || _req$user5 === void 0 ? void 0 : _req$user5.powrId; // From JWT token

    if (!userId) {
      return res.status(401).json({
        success: false,
        message: "User not authenticated"
      });
    }
    if (typeof enabled !== 'boolean') {
      return res.status(400).json({
        success: false,
        message: "Enabled must be a boolean"
      });
    }
    const result = await toolsManager.toggleTool(userId, toolId, enabled);
    if (result.success) {
      return res.status(200).json(result);
    } else {
      return res.status(400).json(result);
    }
  } catch (error) {
    console.error("Error toggling user tool:", error);
    return res.status(500).json({
      success: false,
      message: "Failed to toggle user tool."
    });
  }
});

// Get tool execution history
router.get('/user/:toolId/history', async (req, res) => {
  try {
    var _req$user6;
    const {
      toolId
    } = req.params;
    const userId = (_req$user6 = req.user) === null || _req$user6 === void 0 ? void 0 : _req$user6.powrId; // From JWT token

    if (!userId) {
      return res.status(401).json({
        success: false,
        message: "User not authenticated"
      });
    }
    const db = await getDb();
    const executions = await db.collection("tool_executions").find({
      userId,
      toolId
    }).sort({
      timestamp: -1
    }).limit(50).toArray();
    return res.status(200).json({
      success: true,
      data: executions,
      total: executions.length
    });
  } catch (error) {
    console.error("Error retrieving tool execution history:", error);
    return res.status(500).json({
      success: false,
      message: "Failed to retrieve tool execution history."
    });
  }
});
module.exports = router;