powr-sdk-api 4.2.0 → 4.3.0

package/dist/routes/scheduledTasks.js

@@ -1,240 +0,0 @@
-"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/scripts/update-tools-schema.js

@@ -1,157 +0,0 @@
-"use strict";
-
-const {
-  getDb
-} = require('../services/mongo');
-async function updateToolsSchema() {
-  try {
-    const db = await getDb();
-
-    // Update Gmail tool with proper config schema
-    await db.collection('tools').updateOne({
-      id: 'gmail'
-    }, {
-      $set: {
-        configSchema: {
-          email: {
-            label: 'Email Address',
-            type: 'email',
-            required: true,
-            placeholder: 'your-email@gmail.com',
-            description: 'Your Gmail address'
-          },
-          appPassword: {
-            label: 'App Password',
-            type: 'password',
-            required: true,
-            placeholder: '16-character app password',
-            description: 'Gmail App Password (not your regular password)'
-          }
-        },
-        actions: [{
-          id: 'send-email',
-          name: 'Send Email',
-          description: 'Send an email using Gmail SMTP',
-          parameters: {
-            to: {
-              type: 'string',
-              required: true,
-              description: 'Recipient email address'
-            },
-            subject: {
-              type: 'string',
-              required: true,
-              description: 'Email subject'
-            },
-            body: {
-              type: 'string',
-              required: true,
-              description: 'Email body content'
-            }
-          }
-        }]
-      }
-    });
-
-    // Update Slack tool with proper config schema
-    await db.collection('tools').updateOne({
-      id: 'slack'
-    }, {
-      $set: {
-        configSchema: {
-          botToken: {
-            label: 'Bot Token',
-            type: 'password',
-            required: true,
-            placeholder: 'xoxb-your-bot-token',
-            description: 'Slack Bot User OAuth Token'
-          },
-          channelId: {
-            label: 'Default Channel ID',
-            type: 'text',
-            required: false,
-            placeholder: 'C1234567890',
-            description: 'Default Slack channel ID (optional)'
-          }
-        },
-        actions: [{
-          id: 'send-message',
-          name: 'Send Message',
-          description: 'Send a message to a Slack channel',
-          parameters: {
-            channel: {
-              type: 'string',
-              required: true,
-              description: 'Channel ID or name'
-            },
-            message: {
-              type: 'string',
-              required: true,
-              description: 'Message content'
-            }
-          }
-        }]
-      }
-    });
-
-    // Update GitHub tool with proper config schema
-    await db.collection('tools').updateOne({
-      id: 'github'
-    }, {
-      $set: {
-        configSchema: {
-          accessToken: {
-            label: 'Personal Access Token',
-            type: 'password',
-            required: true,
-            placeholder: 'ghp_your-token',
-            description: 'GitHub Personal Access Token'
-          },
-          username: {
-            label: 'GitHub Username',
-            type: 'text',
-            required: true,
-            placeholder: 'your-github-username',
-            description: 'Your GitHub username'
-          }
-        },
-        actions: [{
-          id: 'create-issue',
-          name: 'Create Issue',
-          description: 'Create a new issue in a repository',
-          parameters: {
-            repo: {
-              type: 'string',
-              required: true,
-              description: 'Repository name (owner/repo)'
-            },
-            title: {
-              type: 'string',
-              required: true,
-              description: 'Issue title'
-            },
-            body: {
-              type: 'string',
-              required: false,
-              description: 'Issue description'
-            }
-          }
-        }]
-      }
-    });
-    console.log('✅ Updated tools with proper configuration schemas');
-
-    // Verify the updates
-    const tools = await db.collection('tools').find({}).toArray();
-    console.log('📋 Current tools:');
-    tools.forEach(tool => {
-      var _tool$actions;
-      console.log(`  - ${tool.name}: ${((_tool$actions = tool.actions) === null || _tool$actions === void 0 ? void 0 : _tool$actions.length) || 0} actions, ${Object.keys(tool.configSchema || {}).length} config fields`);
-    });
-  } catch (error) {
-    console.error('❌ Error updating tools schema:', error);
-  } finally {
-    process.exit(0);
-  }
-}
-updateToolsSchema();

package/dist/services/dbService.js

@@ -1,42 +0,0 @@
-"use strict";
-
-const {
-  MongoClient
-} = require('mongodb');
-const {
-  config
-} = require('../config');
-const mongoClient = new MongoClient(config.mongoUri, {
-  maxPoolSize: 10,
-  serverSelectionTimeoutMS: 5000,
-  socketTimeoutMS: 45000
-});
-let db;
-async function connect() {
-  try {
-    await mongoClient.connect();
-    db = mongoClient.db();
-    console.log("Connected to MongoDB via SDK");
-  } catch (error) {
-    console.error("Failed to connect to MongoDB:", error);
-    process.exit(1);
-  }
-}
-function getDb() {
-  if (!db) {
-    throw new Error("Database not initialized. Call connectToMongo() first.");
-  }
-  return db;
-}
-const closeConnection = async () => {
-  if (mongoClient) {
-    await mongoClient.close();
-    db = null;
-    console.log('✅ MongoDB connection closed');
-  }
-};
-module.exports = {
-  connect,
-  getDb,
-  closeConnection
-};

package/dist/services/logger.js

@@ -1,35 +0,0 @@
-"use strict";
-
-const winston = require('winston');
-const {
-  S3Transport
-} = require('../utils/s3');
-
-// Custom format for logs
-const logFormat = winston.format.combine(winston.format.timestamp(), winston.format.errors({
-  stack: true
-}), winston.format.json());
-
-// Create base transports array with console transport
-const transports = [new winston.transports.Console()];
-
-// Add S3 transport only in production
-if (process.env.NODE_ENV === 'production') {
-  transports.push(new S3Transport({
-    bucket: process.env.AWS_LOG_BUCKET_NAME,
-    prefix: 'logs',
-    bufferSize: 100,
-    flushInterval: 5000
-  }));
-}
-
-// Create the logger
-const logger = winston.createLogger({
-  level: process.env.LOG_LEVEL || 'info',
-  format: logFormat,
-  defaultMeta: {
-    service: process.env.LOG_SERVICE_NAME
-  },
-  transports
-});
-module.exports = logger;

package/dist/services/plexx.js

@@ -1,229 +0,0 @@
-"use strict";
-
-const {
-  getDb
-} = require("./mongo");
-const crypto = require('crypto');
-const config = require('../config');
-class PlexxManager {
-  constructor() {
-    this.compiledFunctions = new Map();
-    this.isInitialized = false;
-    this.isCentralService = false;
-    this.isEnabled = false; // Default disabled
-  }
-  async initialize(options = {}) {
-    this.isCentralService = options.isCentralService || false;
-    this.isEnabled = options.enablePlexx === true; // Default false unless explicitly enabled
-
-    if (!this.isEnabled) {
-      console.log("🚫 Plexx is disabled");
-      this.isInitialized = true;
-      return;
-    }
-    if (this.isCentralService) {
-      // Central service: Don't pre-load, load dynamically
-      console.log("🔄 Central service mode - loading routes dynamically");
-      this.isInitialized = true;
-    } else {
-      // Individual API: Load only this project's routes
-      const projectId = config.projectId;
-      console.log(`📦 Loading routes for project: ${projectId}`);
-      try {
-        const db = await getDb();
-        const routes = await db.collection("routes").find({
-          projectId
-        }).toArray();
-        routes.forEach(route => {
-          this.compileAndCache(route);
-        });
-        this.isInitialized = true;
-        console.log(`✅ Pre-compiled ${routes.length} routes for project ${projectId}`);
-      } catch (error) {
-        console.error("❌ Failed to initialize routes:", error);
-        this.isInitialized = true; // Still mark as initialized to prevent blocking
-      }
-    }
-  }
-  compileAndCache(route) {
-    const cacheKey = `${route.projectId}:${route.route}`;
-    try {
-      // Security validation
-      if (!this.validateCode(route.code)) {
-        console.error(`❌ Invalid code in route: ${route.route}`);
-        return;
-      }
-
-      // Pre-compile function
-      const compiledFunction = new Function("params", route.code);
-      this.compiledFunctions.set(cacheKey, {
-        function: compiledFunction,
-        metadata: {
-          route: route.route,
-          projectId: route.projectId,
-          compiledAt: new Date(),
-          codeHash: this.generateHash(route.code)
-        }
-      });
-      console.log(`✅ Compiled: ${route.route}`);
-    } catch (error) {
-      console.error(`❌ Failed to compile ${route.route}:`, error);
-    }
-  }
-  async execute(projectId, route, params) {
-    if (!this.isEnabled) {
-      return {
-        success: false,
-        message: "Plexx is disabled",
-        data: null
-      };
-    }
-    const cacheKey = `${projectId}:${route}`;
-    const cached = this.compiledFunctions.get(cacheKey);
-    if (!cached) {
-      if (this.isCentralService) {
-        // Try to load only the specific route dynamically
-        await this.loadSpecificRoute(projectId, route);
-        const retryCached = this.compiledFunctions.get(cacheKey);
-        if (retryCached) {
-          return retryCached.function(params);
-        }
-      }
-      return {
-        success: false,
-        message: `Route not found: ${route}`,
-        data: null
-      };
-    }
-    try {
-      const result = cached.function(params);
-      return {
-        success: true,
-        message: "Route executed successfully",
-        data: result
-      };
-    } catch (error) {
-      return {
-        success: false,
-        message: `Error executing route: ${error.message}`,
-        data: null,
-        error: error.message
-      };
-    }
-  }
-
-  // Load specific route for central service
-  async loadSpecificRoute(projectId, route) {
-    if (!this.isCentralService) {
-      throw new Error("Dynamic loading only available in central service mode");
-    }
-    try {
-      const db = await getDb();
-      const routeData = await db.collection("routes").findOne({
-        projectId,
-        route
-      });
-      if (routeData) {
-        this.compileAndCache(routeData);
-        console.log(`✅ Loaded route: ${route} for project ${projectId}`);
-      } else {
-        console.log(`❌ Route not found: ${route} for project ${projectId}`);
-      }
-    } catch (error) {
-      console.error(`❌ Failed to load route ${route} for project ${projectId}:`, error);
-      throw error;
-    }
-  }
-
-  // Dynamic loading for central service
-  async loadProjectRoutes(projectId) {
-    if (!this.isCentralService) {
-      throw new Error("Dynamic loading only available in central service mode");
-    }
-    try {
-      const db = await getDb();
-      const routes = await db.collection("routes").find({
-        projectId
-      }).toArray();
-      routes.forEach(route => {
-        this.compileAndCache(route);
-      });
-      console.log(`✅ Loaded ${routes.length} routes for project ${projectId}`);
-    } catch (error) {
-      console.error(`❌ Failed to load routes for project ${projectId}:`, error);
-      throw error;
-    }
-  }
-
-  // Security validation
-  validateCode(code) {
-    const dangerousPatterns = [/process\./, /require\(/, /eval\(/, /setTimeout\(/, /setInterval\(/, /global\./, /__dirname/, /__filename/];
-    return !dangerousPatterns.some(pattern => pattern.test(code));
-  }
-
-  // Generate hash for change detection
-  generateHash(code) {
-    return crypto.createHash('md5').update(code).digest('hex');
-  }
-
-  // Update route (re-compile)
-  async updateRoute(projectId, route, newCode) {
-    const routeData = {
-      projectId,
-      route,
-      code: newCode
-    };
-    this.compileAndCache(routeData);
-
-    // Optionally save to database
-    try {
-      const db = await getDb();
-      await db.collection("routes").updateOne({
-        projectId,
-        route
-      }, {
-        $set: {
-          code: newCode,
-          updatedAt: new Date()
-        }
-      });
-    } catch (error) {
-      console.error(`❌ Failed to update route in database: ${route}`, error);
-    }
-  }
-
-  // Get route statistics
-  getStats() {
-    return {
-      totalRoutes: this.compiledFunctions.size,
-      isInitialized: this.isInitialized,
-      isCentralService: this.isCentralService,
-      isEnabled: this.isEnabled,
-      cacheKeys: Array.from(this.compiledFunctions.keys())
-    };
-  }
-
-  // Clear cache (for testing or maintenance)
-  clearCache() {
-    this.compiledFunctions.clear();
-    console.log("🧹 Route cache cleared");
-  }
-
-  // Enable/Disable Plexx
-  enable() {
-    this.isEnabled = true;
-    console.log("✅ Plexx enabled");
-  }
-  disable() {
-    this.isEnabled = false;
-    console.log("🚫 Plexx disabled");
-  }
-
-  // Toggle Plexx
-  toggle() {
-    this.isEnabled = !this.isEnabled;
-    console.log(this.isEnabled ? "✅ Plexx enabled" : "🚫 Plexx disabled");
-    return this.isEnabled;
-  }
-}
-module.exports = new PlexxManager();