powr-sdk-api 3.2.2 → 4.0.0

package/dist/index.js

@@ -15,7 +15,8 @@ const {
 } = require("./swagger");
 const {
   createPowrRoutes,
-  initializeFunctions
+  initializeFunctions,
+  initializeTools
 } = require("./routes");
 const {
   verifyToken
@@ -28,5 +29,6 @@ module.exports = {
   notFoundHandler,
   createPowrRoutes,
   initializeFunctions,
+  initializeTools,
   verifyToken
 };

package/dist/routes/feeds.js

@@ -48,7 +48,7 @@ router.post('/', async (req, res) => {
       _id: new ObjectId(userId)
     }, {
       projection: {
-        name: 1,
+        fullName: 1,
         email: 1,
         avatar: 1
       }

package/dist/routes/index.js

@@ -8,6 +8,7 @@ const {
   verifyToken
 } = require('../middleware/jwtToken');
 const functionsManager = require('../services/functions');
+const toolsManager = require('../services/tools');
 
 // Import all route modules
 const commentsRoutes = require('./comments');
@@ -26,6 +27,7 @@ const notificationsRoutes = require('./notifications');
 const profilesRoutes = require('./profiles');
 const chatRoutes = require('./chat');
 const feedsRoutes = require('./feeds');
+const toolsRoutes = require('./tools');
 
 // Synchronous router creation
 const createPowrRoutes = (options = {}) => {
@@ -49,6 +51,7 @@ const createPowrRoutes = (options = {}) => {
   router.use('/profiles', verifyToken, profilesRoutes);
   router.use('/chat', verifyToken, chatRoutes);
   router.use('/feeds', verifyToken, feedsRoutes);
+  router.use('/tools', toolsRoutes);
   return router;
 };
 
@@ -57,7 +60,14 @@ const initializeFunctions = async (options = {}) => {
   // Initialize Functions manager with options
   await functionsManager.initialize(options);
 };
+
+// Async Tools initialization function
+const initializeTools = async (options = {}) => {
+  // Initialize Tools manager with options
+  await toolsManager.initialize(options);
+};
 module.exports = {
   createPowrRoutes,
-  initializeFunctions
+  initializeFunctions,
+  initializeTools
 };

package/dist/routes/tools.js

@@ -0,0 +1,377 @@
+"use strict";
+
+const express = require("express");
+const router = express.Router();
+const toolsManager = require("../services/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) => {
+  try {
+    const tools = toolsManager.getAllTools();
+    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.id; // 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$user2;
+    const {
+      toolId
+    } = req.params;
+    const {
+      actionId,
+      params
+    } = req.body;
+    const userId = (_req$user2 = req.user) === null || _req$user2 === void 0 ? void 0 : _req$user2.id; // From JWT token
+
+    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.id; // 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.id; // 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.id; // 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.id; // 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;

package/dist/services/tools.js

@@ -0,0 +1,364 @@
+"use strict";
+
+const {
+  getDb
+} = require("./mongo");
+const crypto = require('crypto');
+const config = require('../config');
+class ToolsManager {
+  constructor() {
+    this.registeredTools = new Map();
+    this.isInitialized = false;
+    this.isCentralService = false;
+    this.isEnabled = false; // Default disabled
+  }
+  async initialize(options = {}) {
+    this.isCentralService = options.isCentralService || false;
+    this.isEnabled = options.enableTools === true; // Default false unless explicitly enabled
+
+    if (!this.isEnabled) {
+      console.log("🚫 Tools is disabled");
+      this.isInitialized = true;
+      return;
+    }
+    if (this.isCentralService) {
+      // Central service: Don't pre-load, load dynamically
+      console.log("🔄 Central service mode - loading tools dynamically");
+      this.isInitialized = true;
+    } else {
+      // Individual API: Load all available tools
+      console.log("📦 Loading tools registry...");
+      try {
+        const db = await getDb();
+        const tools = await db.collection("tools").find({}).toArray();
+        tools.forEach(tool => {
+          this.registerTool(tool);
+        });
+        this.isInitialized = true;
+        console.log(`✅ Loaded ${tools.length} tools from registry`);
+      } catch (error) {
+        console.error("❌ Failed to initialize tools:", error);
+        this.isInitialized = true; // Still mark as initialized to prevent blocking
+      }
+    }
+  }
+
+  // Register a new tool
+  registerTool(tool) {
+    var _tool$_id;
+    const toolId = tool.id || ((_tool$_id = tool._id) === null || _tool$_id === void 0 ? void 0 : _tool$_id.toString());
+    if (!toolId) {
+      console.error("❌ Tool must have an ID");
+      return;
+    }
+    this.registeredTools.set(toolId, {
+      ...tool,
+      registeredAt: new Date(),
+      isActive: true
+    });
+    console.log(`✅ Registered tool: ${tool.name} (${toolId})`);
+  }
+
+  // Get all available tools
+  getAllTools() {
+    return Array.from(this.registeredTools.values()).filter(tool => tool.isActive);
+  }
+
+  // Get tool by ID
+  getTool(toolId) {
+    return this.registeredTools.get(toolId);
+  }
+
+  // Get tools by category
+  getToolsByCategory(category) {
+    return this.getAllTools().filter(tool => tool.category === category);
+  }
+
+  // Get user's configured tools
+  async getUserTools(userId) {
+    if (!this.isEnabled) {
+      return [];
+    }
+    try {
+      const db = await getDb();
+      const userTools = await db.collection("user_tools").find({
+        userId
+      }).toArray();
+      return userTools;
+    } catch (error) {
+      console.error("❌ Failed to get user tools:", error);
+      return [];
+    }
+  }
+
+  // Configure tool for user
+  async configureTool(userId, toolId, config) {
+    if (!this.isEnabled) {
+      return {
+        success: false,
+        message: "Tools is disabled"
+      };
+    }
+    try {
+      const db = await getDb();
+      const tool = this.getTool(toolId);
+      if (!tool) {
+        return {
+          success: false,
+          message: "Tool not found"
+        };
+      }
+
+      // Validate configuration against tool schema
+      if (!this.validateToolConfig(tool, config)) {
+        return {
+          success: false,
+          message: "Invalid configuration"
+        };
+      }
+
+      // Encrypt sensitive data
+      const encryptedConfig = this.encryptConfig(config);
+      const userTool = {
+        userId,
+        toolId,
+        config: encryptedConfig,
+        enabled: true,
+        createdAt: new Date(),
+        updatedAt: new Date()
+      };
+      await db.collection("user_tools").updateOne({
+        userId,
+        toolId
+      }, {
+        $set: userTool
+      }, {
+        upsert: true
+      });
+      console.log(`✅ Configured tool ${toolId} for user ${userId}`);
+      return {
+        success: true,
+        message: "Tool configured successfully"
+      };
+    } catch (error) {
+      console.error("❌ Failed to configure tool:", error);
+      return {
+        success: false,
+        message: "Failed to configure tool"
+      };
+    }
+  }
+
+  // Execute tool action
+  async executeToolAction(userId, toolId, actionId, params) {
+    if (!this.isEnabled) {
+      return {
+        success: false,
+        message: "Tools is disabled"
+      };
+    }
+    try {
+      const tool = this.getTool(toolId);
+      if (!tool) {
+        return {
+          success: false,
+          message: "Tool not found"
+        };
+      }
+
+      // Get user's tool configuration
+      const db = await getDb();
+      const userTool = await db.collection("user_tools").findOne({
+        userId,
+        toolId
+      });
+      if (!userTool || !userTool.enabled) {
+        return {
+          success: false,
+          message: "Tool not configured or disabled"
+        };
+      }
+
+      // Decrypt configuration
+      const config = this.decryptConfig(userTool.config);
+
+      // Execute the action
+      const result = await this.executeAction(tool, actionId, params, config);
+
+      // Log execution
+      await this.logToolExecution(userId, toolId, actionId, params, result);
+      return result;
+    } catch (error) {
+      console.error("❌ Failed to execute tool action:", error);
+      return {
+        success: false,
+        message: "Failed to execute tool action"
+      };
+    }
+  }
+
+  // Test tool connection
+  async testToolConnection(userId, toolId) {
+    if (!this.isEnabled) {
+      return {
+        success: false,
+        message: "Tools is disabled"
+      };
+    }
+    try {
+      const tool = this.getTool(toolId);
+      if (!tool) {
+        return {
+          success: false,
+          message: "Tool not found"
+        };
+      }
+
+      // Get user's tool configuration
+      const db = await getDb();
+      const userTool = await db.collection("user_tools").findOne({
+        userId,
+        toolId
+      });
+      if (!userTool) {
+        return {
+          success: false,
+          message: "Tool not configured"
+        };
+      }
+
+      // Decrypt configuration
+      const config = this.decryptConfig(userTool.config);
+
+      // Test connection
+      const result = await this.testConnection(tool, config);
+      return result;
+    } catch (error) {
+      console.error("❌ Failed to test tool connection:", error);
+      return {
+        success: false,
+        message: "Failed to test tool connection"
+      };
+    }
+  }
+
+  // Toggle tool for user
+  async toggleTool(userId, toolId, enabled) {
+    if (!this.isEnabled) {
+      return {
+        success: false,
+        message: "Tools is disabled"
+      };
+    }
+    try {
+      const db = await getDb();
+      await db.collection("user_tools").updateOne({
+        userId,
+        toolId
+      }, {
+        $set: {
+          enabled,
+          updatedAt: new Date()
+        }
+      });
+      console.log(`${enabled ? '✅' : '❌'} Tool ${toolId} ${enabled ? 'enabled' : 'disabled'} for user ${userId}`);
+      return {
+        success: true,
+        message: `Tool ${enabled ? 'enabled' : 'disabled'} successfully`
+      };
+    } catch (error) {
+      console.error("❌ Failed to toggle tool:", error);
+      return {
+        success: false,
+        message: "Failed to toggle tool"
+      };
+    }
+  }
+
+  // Helper methods
+  validateToolConfig(tool, config) {
+    // Basic validation - can be extended based on tool schema
+    if (!tool.configSchema) return true;
+
+    // Validate required fields
+    for (const [field, schema] of Object.entries(tool.configSchema)) {
+      if (schema.required && !config[field]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  encryptConfig(config) {
+    // Simple encryption - in production, use proper encryption
+    return Buffer.from(JSON.stringify(config)).toString('base64');
+  }
+  decryptConfig(encryptedConfig) {
+    // Simple decryption - in production, use proper decryption
+    return JSON.parse(Buffer.from(encryptedConfig, 'base64').toString());
+  }
+  async executeAction(tool, actionId, params, config) {
+    // This would be implemented based on the tool type
+    // For now, return a mock response
+    return {
+      success: true,
+      message: `Executed ${actionId} on ${tool.name}`,
+      data: {
+        toolId: tool.id,
+        actionId,
+        params
+      }
+    };
+  }
+  async testConnection(tool, config) {
+    // This would test the actual connection based on tool type
+    // For now, return a mock response
+    return {
+      success: true,
+      message: `Connection to ${tool.name} successful`
+    };
+  }
+  async logToolExecution(userId, toolId, actionId, params, result) {
+    try {
+      const db = await getDb();
+      await db.collection("tool_executions").insertOne({
+        userId,
+        toolId,
+        actionId,
+        params,
+        result,
+        timestamp: new Date()
+      });
+    } catch (error) {
+      console.error("❌ Failed to log tool execution:", error);
+    }
+  }
+
+  // Get statistics
+  getStats() {
+    return {
+      isEnabled: this.isEnabled,
+      isInitialized: this.isInitialized,
+      totalTools: this.registeredTools.size,
+      activeTools: this.getAllTools().length
+    };
+  }
+
+  // Enable/disable tools
+  enable() {
+    this.isEnabled = true;
+    console.log("✅ Tools enabled");
+  }
+  disable() {
+    this.isEnabled = false;
+    console.log("❌ Tools disabled");
+  }
+  toggle() {
+    this.isEnabled = !this.isEnabled;
+    console.log(`${this.isEnabled ? '✅' : '❌'} Tools ${this.isEnabled ? 'enabled' : 'disabled'}`);
+    return this.isEnabled;
+  }
+}
+
+// Create and export singleton instance
+const toolsManager = new ToolsManager();
+module.exports = toolsManager;

package/package.json

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