@friggframework/devtools 2.0.0--canary.400.bed3308.0 → 2.0.0--canary.404.e9d4980.0

package/management-ui/server/api/discovery.js

@@ -1,185 +0,0 @@
-import express from 'express'
-import fetch from 'node-fetch'
-import { createStandardResponse } from '../utils/response.js'
-
-const router = express.Router()
-
-// Get real integrations from NPM registry
-async function fetchRealIntegrations() {
-  try {
-    const searchUrl = 'https://registry.npmjs.org/-/v1/search?text=@friggframework%20api-module&size=100';
-    
-    const response = await fetch(searchUrl);
-    if (!response.ok) {
-      throw new Error(`NPM search failed: ${response.statusText}`);
-    }
-
-    const data = await response.json();
-    
-    return data.objects
-      .filter(pkg => pkg.package.name.includes('@friggframework/api-module-'))
-      .map(pkg => ({
-        id: pkg.package.name.replace('@friggframework/api-module-', ''),
-        name: pkg.package.name.replace('@friggframework/api-module-', '').replace('-', ' ').split(' ').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' '),
-        description: pkg.package.description || 'No description available',
-        category: detectCategory(pkg.package.name, pkg.package.description || '', pkg.package.keywords || []),
-        status: 'available',
-        installed: false,
-        version: pkg.package.version,
-        packageName: pkg.package.name
-      }));
-  } catch (error) {
-    console.error('Error fetching real integrations:', error);
-    // Fallback to basic integrations
-    return [
-      {
-        id: 'hubspot',
-        name: 'HubSpot',
-        description: 'CRM and marketing platform integration',
-        category: 'crm',
-        status: 'available',
-        installed: false,
-        version: '2.0.0',
-        packageName: '@friggframework/api-module-hubspot'
-      }
-    ];
-  }
-}
-
-// Helper to detect integration category
-function detectCategory(name, description, keywords) {
-  const text = `${name} ${description} ${keywords.join(' ')}`.toLowerCase();
-  
-  const categoryPatterns = {
-    'crm': ['crm', 'customer', 'salesforce', 'hubspot', 'pipedrive'],
-    'communication': ['email', 'sms', 'chat', 'slack', 'discord', 'teams'],
-    'marketing': ['marketing', 'campaign', 'mailchimp', 'activecampaign'],
-    'productivity': ['task', 'project', 'asana', 'trello', 'notion', 'jira'],
-    'support': ['support', 'helpdesk', 'ticket', 'zendesk', 'intercom'],
-    'finance': ['accounting', 'invoice', 'quickbooks', 'xero', 'billing']
-  };
-
-  for (const [category, patterns] of Object.entries(categoryPatterns)) {
-    for (const pattern of patterns) {
-      if (text.includes(pattern)) {
-        return category;
-      }
-    }
-  }
-  
-  return 'other';
-}
-
-// Get integration categories  
-router.get('/categories', async (req, res) => {
-  try {
-    const integrations = await fetchRealIntegrations();
-    
-    // Count integrations by category
-    const categoryCounts = integrations.reduce((acc, integration) => {
-      const category = integration.category;
-      acc[category] = (acc[category] || 0) + 1;
-      return acc;
-    }, {});
-    
-    const categories = Object.entries(categoryCounts).map(([id, count]) => ({
-      id,
-      name: id.charAt(0).toUpperCase() + id.slice(1),
-      count
-    }));
-    
-    res.json({
-      status: 'success',
-      data: categories
-    });
-  } catch (error) {
-    console.error('Error fetching categories:', error);
-    res.status(500).json({
-      status: 'error',
-      message: 'Failed to fetch categories'
-    });
-  }
-})
-
-// Get all integrations
-router.get('/integrations', async (req, res) => {
-  try {
-    const { category, status, installed } = req.query;
-    
-    let integrations = await fetchRealIntegrations();
-    
-    // Filter by category
-    if (category && category !== 'all') {
-      integrations = integrations.filter(i => i.category === category);
-    }
-    
-    // Filter by status
-    if (status) {
-      integrations = integrations.filter(i => i.status === status);
-    }
-    
-    // Filter by installed
-    if (installed !== undefined) {
-      integrations = integrations.filter(i => i.installed === (installed === 'true'));
-    }
-    
-    res.json({
-      status: 'success',
-      data: {
-        integrations,
-        total: integrations.length
-      }
-    });
-  } catch (error) {
-    console.error('Error fetching integrations:', error);
-    res.status(500).json({
-      status: 'error',
-      message: 'Failed to fetch integrations'
-    });
-  }
-})
-
-// Get installed integrations
-router.get('/installed', async (req, res) => {
-  try {
-    // Import the integration detection logic
-    const { getInstalledIntegrations } = await import('./integrations.js');
-    const installedIntegrations = await getInstalledIntegrations();
-    
-    // Format for discovery API
-    const formatted = installedIntegrations.map(integration => ({
-      id: integration.name.toLowerCase(),
-      name: integration.name,
-      description: integration.description,
-      category: integration.category,
-      status: 'installed',
-      installed: true,
-      version: '1.0.0' // We don't have version info for actual integrations
-    }));
-    
-    res.json({
-      status: 'success',
-      data: formatted
-    });
-  } catch (error) {
-    console.error('Error fetching installed integrations:', error);
-    res.status(500).json({
-      status: 'error',
-      message: 'Failed to fetch installed integrations'
-    });
-  }
-})
-
-// Clear discovery cache
-router.post('/cache/clear', (req, res) => {
-  // In a real implementation, this would clear actual cache
-  res.json({
-    status: 'success',
-    data: {
-      message: 'Discovery cache cleared successfully',
-      timestamp: new Date().toISOString()
-    }
-  })
-})
-
-export default router

package/management-ui/server/api/environment/index.js

@@ -1 +0,0 @@
-export { default as environmentRouter } from './router.js';

package/management-ui/server/api/environment/router.js

@@ -1,378 +0,0 @@
-import express from 'express';
-import path from 'path';
-import EnvFileManager from '../../utils/environment/envFileManager.js';
-import AWSParameterStore from '../../utils/environment/awsParameterStore.js';
-
-const router = express.Router();
-
-// Initialize managers
-const projectRoot = process.env.PROJECT_ROOT || path.resolve(process.cwd(), '../../../');
-const envManager = new EnvFileManager(projectRoot);
-const awsManager = new AWSParameterStore({
-  prefix: process.env.AWS_PARAMETER_PREFIX || '/frigg',
-  region: process.env.AWS_REGION || 'us-east-1'
-});
-
-// Middleware to validate environment parameter
-const validateEnvironment = (req, res, next) => {
-  const validEnvironments = ['local', 'staging', 'production'];
-  const { environment } = req.params;
-  
-  if (!validEnvironments.includes(environment)) {
-    return res.status(400).json({
-      error: 'Invalid environment',
-      validEnvironments
-    });
-  }
-  
-  next();
-};
-
-// GET /api/environment/variables/:environment
-router.get('/variables/:environment', validateEnvironment, async (req, res) => {
-  try {
-    const { environment } = req.params;
-    const { includeAws } = req.query;
-    
-    // Get variables from .env file
-    const fileVariables = await envManager.readEnvFile(environment);
-    
-    let variables = fileVariables;
-    
-    // Merge with AWS if requested and environment is production
-    if (includeAws === 'true' && environment === 'production') {
-      try {
-        const awsVariables = await awsManager.getParameters(environment);
-        variables = envManager.mergeVariables(fileVariables, awsVariables, true);
-      } catch (awsError) {
-        console.error('AWS fetch error:', awsError);
-        // Continue with file variables only
-      }
-    }
-    
-    res.json({
-      environment,
-      variables,
-      source: includeAws === 'true' ? 'merged' : 'file'
-    });
-  } catch (error) {
-    console.error('Error fetching variables:', error);
-    res.status(500).json({
-      error: 'Failed to fetch environment variables',
-      message: error.message
-    });
-  }
-});
-
-// PUT /api/environment/variables/:environment
-router.put('/variables/:environment', validateEnvironment, async (req, res) => {
-  try {
-    const { environment } = req.params;
-    const { variables } = req.body;
-    
-    if (!Array.isArray(variables)) {
-      return res.status(400).json({
-        error: 'Variables must be an array'
-      });
-    }
-    
-    // Validate variables
-    const errors = envManager.validateVariables(variables);
-    if (errors.length > 0) {
-      return res.status(400).json({
-        error: 'Validation errors',
-        errors
-      });
-    }
-    
-    // Write to file
-    const result = await envManager.writeEnvFile(environment, variables);
-    
-    res.json({
-      success: true,
-      environment,
-      count: variables.length,
-      ...result
-    });
-  } catch (error) {
-    console.error('Error saving variables:', error);
-    res.status(500).json({
-      error: 'Failed to save environment variables',
-      message: error.message
-    });
-  }
-});
-
-// POST /api/environment/sync/aws-parameter-store
-router.post('/sync/aws-parameter-store', async (req, res) => {
-  try {
-    const { environment } = req.body;
-    
-    if (environment !== 'production') {
-      return res.status(400).json({
-        error: 'AWS sync is only available for production environment'
-      });
-    }
-    
-    // Validate AWS access
-    const accessCheck = await awsManager.validateAccess();
-    if (!accessCheck.valid) {
-      return res.status(403).json({
-        error: 'AWS access denied',
-        message: accessCheck.error,
-        code: accessCheck.code
-      });
-    }
-    
-    // Get variables from file
-    const fileVariables = await envManager.readEnvFile(environment);
-    
-    // Sync to AWS
-    const syncResult = await awsManager.syncEnvironment(environment, fileVariables);
-    
-    res.json({
-      success: true,
-      environment,
-      count: fileVariables.length,
-      ...syncResult
-    });
-  } catch (error) {
-    console.error('Error syncing to AWS:', error);
-    res.status(500).json({
-      error: 'Failed to sync with AWS Parameter Store',
-      message: error.message
-    });
-  }
-});
-
-// GET /api/environment/export/:environment
-router.get('/export/:environment', validateEnvironment, async (req, res) => {
-  try {
-    const { environment } = req.params;
-    const { format, excludeSecrets } = req.query;
-    
-    const variables = await envManager.readEnvFile(environment);
-    
-    let exportData;
-    let contentType;
-    let filename;
-    
-    if (format === 'json') {
-      // Export as JSON
-      const data = {};
-      variables.forEach(v => {
-        if (!excludeSecrets || !v.isSecret) {
-          data[v.key] = v.value;
-        }
-      });
-      
-      exportData = JSON.stringify(data, null, 2);
-      contentType = 'application/json';
-      filename = `${environment}-env.json`;
-    } else {
-      // Export as .env format
-      let content = `# Environment: ${environment}\n`;
-      content += `# Exported: ${new Date().toISOString()}\n\n`;
-      
-      const sorted = variables.sort((a, b) => a.key.localeCompare(b.key));
-      
-      for (const v of sorted) {
-        if (v.description) {
-          content += `# ${v.description}\n`;
-        }
-        
-        const value = (excludeSecrets === 'true' && v.isSecret) ? '**REDACTED**' : v.value;
-        content += `${v.key}=${envManager.escapeValue(value)}\n\n`;
-      }
-      
-      exportData = content.trim();
-      contentType = 'text/plain';
-      filename = environment === 'local' ? '.env' : `.env.${environment}`;
-    }
-    
-    res.setHeader('Content-Type', contentType);
-    res.setHeader('Content-Disposition', `attachment; filename="${filename}"`);
-    res.send(exportData);
-  } catch (error) {
-    console.error('Error exporting variables:', error);
-    res.status(500).json({
-      error: 'Failed to export environment variables',
-      message: error.message
-    });
-  }
-});
-
-// POST /api/environment/import/:environment
-router.post('/import/:environment', validateEnvironment, async (req, res) => {
-  try {
-    const { environment } = req.params;
-    const { data, format, merge } = req.body;
-    
-    if (!data) {
-      return res.status(400).json({
-        error: 'No data provided for import'
-      });
-    }
-    
-    let importedVariables = [];
-    
-    if (format === 'json') {
-      // Import from JSON
-      const parsed = typeof data === 'string' ? JSON.parse(data) : data;
-      importedVariables = Object.entries(parsed).map(([key, value]) => ({
-        id: `${environment}-${key}-${Date.now()}`,
-        key,
-        value: String(value),
-        description: '',
-        isSecret: envManager.isSecretVariable(key),
-        environment
-      }));
-    } else {
-      // Import from .env format
-      const lines = data.split('\n');
-      let currentDescription = '';
-      
-      for (const line of lines) {
-        const trimmed = line.trim();
-        
-        if (trimmed.startsWith('#')) {
-          currentDescription = trimmed.substring(1).trim();
-        } else if (trimmed && trimmed.includes('=')) {
-          const [key, ...valueParts] = trimmed.split('=');
-          const value = valueParts.join('=').replace(/^["']|["']$/g, '');
-          
-          importedVariables.push({
-            id: `${environment}-${key}-${Date.now()}`,
-            key: key.trim(),
-            value,
-            description: currentDescription,
-            isSecret: envManager.isSecretVariable(key),
-            environment
-          });
-          
-          currentDescription = '';
-        }
-      }
-    }
-    
-    // Validate imported variables
-    const errors = envManager.validateVariables(importedVariables);
-    if (errors.length > 0) {
-      return res.status(400).json({
-        error: 'Validation errors in imported data',
-        errors
-      });
-    }
-    
-    let finalVariables = importedVariables;
-    
-    // Merge with existing if requested
-    if (merge === 'true') {
-      const existing = await envManager.readEnvFile(environment);
-      const merged = [...existing];
-      
-      importedVariables.forEach(importVar => {
-        const existingIndex = merged.findIndex(v => v.key === importVar.key);
-        if (existingIndex >= 0) {
-          merged[existingIndex] = { ...merged[existingIndex], value: importVar.value };
-        } else {
-          merged.push(importVar);
-        }
-      });
-      
-      finalVariables = merged;
-    }
-    
-    // Save variables
-    await envManager.writeEnvFile(environment, finalVariables);
-    
-    res.json({
-      success: true,
-      environment,
-      imported: importedVariables.length,
-      total: finalVariables.length
-    });
-  } catch (error) {
-    console.error('Error importing variables:', error);
-    res.status(500).json({
-      error: 'Failed to import environment variables',
-      message: error.message
-    });
-  }
-});
-
-// POST /api/environment/copy
-router.post('/copy', async (req, res) => {
-  try {
-    const { source, target, excludeSecrets } = req.body;
-    
-    if (!source || !target) {
-      return res.status(400).json({
-        error: 'Source and target environments are required'
-      });
-    }
-    
-    const copiedVariables = await envManager.copyEnvironment(
-      source,
-      target,
-      excludeSecrets === 'true'
-    );
-    
-    res.json({
-      success: true,
-      source,
-      target,
-      count: copiedVariables.length,
-      excludedSecrets: excludeSecrets === 'true'
-    });
-  } catch (error) {
-    console.error('Error copying environment:', error);
-    res.status(500).json({
-      error: 'Failed to copy environment',
-      message: error.message
-    });
-  }
-});
-
-// GET /api/environment/aws/validate
-router.get('/aws/validate', async (req, res) => {
-  try {
-    const validation = await awsManager.validateAccess();
-    res.json(validation);
-  } catch (error) {
-    console.error('Error validating AWS access:', error);
-    res.status(500).json({
-      error: 'Failed to validate AWS access',
-      message: error.message
-    });
-  }
-});
-
-// GET /api/environment/history/:environment/:key
-router.get('/history/:environment/:key', validateEnvironment, async (req, res) => {
-  try {
-    const { environment, key } = req.params;
-    
-    if (environment !== 'production') {
-      return res.status(400).json({
-        error: 'History is only available for production environment (AWS)'
-      });
-    }
-    
-    const history = await awsManager.getParameterHistory(environment, key);
-    
-    res.json({
-      environment,
-      key,
-      history
-    });
-  } catch (error) {
-    console.error('Error fetching parameter history:', error);
-    res.status(500).json({
-      error: 'Failed to fetch parameter history',
-      message: error.message
-    });
-  }
-});
-
-export default router;