@friggframework/devtools 2.0.0--canary.398.dd443c7.0 → 2.0.0--canary.402.d2f4ae6.0

package/management-ui/server/utils/environment/envFileManager.js

@@ -0,0 +1,286 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { parse, stringify } from 'dotenv';
+
+class EnvFileManager {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.environments = {
+      local: '.env.local',
+      staging: '.env.staging',
+      production: '.env.production'
+    };
+  }
+
+  /**
+   * Read environment variables from a specific environment file
+   */
+  async readEnvFile(environment = 'local') {
+    const fileName = this.environments[environment] || '.env';
+    const filePath = path.join(this.projectRoot, fileName);
+    
+    try {
+      const content = await fs.readFile(filePath, 'utf-8');
+      const parsed = parse(content);
+      
+      // Convert to our variable format
+      const variables = Object.entries(parsed).map(([key, value]) => ({
+        id: `${environment}-${key}`,
+        key,
+        value,
+        description: this.extractDescription(content, key),
+        isSecret: this.isSecretVariable(key),
+        environment
+      }));
+      
+      return variables;
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        // File doesn't exist, return empty array
+        return [];
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Write environment variables to a specific environment file
+   */
+  async writeEnvFile(environment, variables) {
+    const fileName = this.environments[environment] || '.env';
+    const filePath = path.join(this.projectRoot, fileName);
+    
+    // Create backup first
+    await this.createBackup(filePath);
+    
+    // Build the content
+    let content = '';
+    const sortedVars = [...variables].sort((a, b) => a.key.localeCompare(b.key));
+    
+    for (const variable of sortedVars) {
+      // Add description as comment if exists
+      if (variable.description) {
+        content += `# ${variable.description}\n`;
+      }
+      
+      // Add the variable
+      const value = this.escapeValue(variable.value);
+      content += `${variable.key}=${value}\n`;
+      
+      // Add extra newline between variables for readability
+      content += '\n';
+    }
+    
+    // Write the file
+    await fs.writeFile(filePath, content.trim());
+    
+    return { success: true, path: filePath };
+  }
+
+  /**
+   * Create a backup of the env file before modifying
+   */
+  async createBackup(filePath) {
+    try {
+      const backupPath = `${filePath}.backup.${Date.now()}`;
+      await fs.copyFile(filePath, backupPath);
+      
+      // Keep only last 5 backups
+      await this.cleanupOldBackups(filePath);
+    } catch (error) {
+      // Ignore if file doesn't exist
+      if (error.code !== 'ENOENT') {
+        throw error;
+      }
+    }
+  }
+
+  /**
+   * Clean up old backup files
+   */
+  async cleanupOldBackups(filePath) {
+    const dir = path.dirname(filePath);
+    const basename = path.basename(filePath);
+    const backupPattern = new RegExp(`^${basename}\\.backup\\.\\d+$`);
+    
+    const files = await fs.readdir(dir);
+    const backups = files
+      .filter(f => backupPattern.test(f))
+      .map(f => ({
+        name: f,
+        path: path.join(dir, f)
+      }));
+    
+    // Sort by timestamp (newest first)
+    backups.sort((a, b) => {
+      const timeA = parseInt(a.name.split('.').pop());
+      const timeB = parseInt(b.name.split('.').pop());
+      return timeB - timeA;
+    });
+    
+    // Delete old backups
+    for (let i = 5; i < backups.length; i++) {
+      await fs.unlink(backups[i].path);
+    }
+  }
+
+  /**
+   * Extract description comment for a variable from the file content
+   */
+  extractDescription(content, key) {
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (line.startsWith(`${key}=`)) {
+        // Check previous line for comment
+        if (i > 0 && lines[i - 1].trim().startsWith('#')) {
+          return lines[i - 1].trim().substring(1).trim();
+        }
+        break;
+      }
+    }
+    return '';
+  }
+
+  /**
+   * Determine if a variable should be treated as secret based on its name
+   */
+  isSecretVariable(key) {
+    const secretPatterns = [
+      /password/i,
+      /secret/i,
+      /key/i,
+      /token/i,
+      /credential/i,
+      /auth/i,
+      /private/i,
+      /api_key/i
+    ];
+    
+    return secretPatterns.some(pattern => pattern.test(key));
+  }
+
+  /**
+   * Escape value for .env file format
+   */
+  escapeValue(value) {
+    // If value contains spaces, newlines, or quotes, wrap in quotes
+    if (/[\s"'`]/.test(value) || value === '') {
+      // Escape any double quotes in the value
+      const escaped = value.replace(/"/g, '\\"');
+      return `"${escaped}"`;
+    }
+    return value;
+  }
+
+  /**
+   * Validate environment variables
+   */
+  validateVariables(variables) {
+    const errors = [];
+    const seen = new Set();
+    
+    for (const variable of variables) {
+      // Check for duplicates
+      if (seen.has(variable.key)) {
+        errors.push({
+          id: variable.id,
+          error: `Duplicate key: ${variable.key}`
+        });
+      }
+      seen.add(variable.key);
+      
+      // Validate key format
+      if (!/^[A-Z_][A-Z0-9_]*$/i.test(variable.key)) {
+        errors.push({
+          id: variable.id,
+          error: `Invalid key format: ${variable.key}`
+        });
+      }
+      
+      // Type-specific validation
+      if (variable.key.endsWith('_PORT') && variable.value) {
+        const port = parseInt(variable.value);
+        if (isNaN(port) || port < 1 || port > 65535) {
+          errors.push({
+            id: variable.id,
+            error: `Invalid port value: ${variable.value}`
+          });
+        }
+      }
+      
+      if (variable.key.endsWith('_URL') && variable.value) {
+        try {
+          new URL(variable.value);
+        } catch {
+          errors.push({
+            id: variable.id,
+            error: `Invalid URL format: ${variable.value}`
+          });
+        }
+      }
+    }
+    
+    return errors;
+  }
+
+  /**
+   * Merge variables from multiple sources (e.g., file and AWS)
+   */
+  mergeVariables(fileVars, externalVars, preferExternal = false) {
+    const merged = new Map();
+    
+    // Add file variables first
+    for (const v of fileVars) {
+      merged.set(v.key, v);
+    }
+    
+    // Merge or override with external variables
+    for (const v of externalVars) {
+      if (preferExternal || !merged.has(v.key)) {
+        merged.set(v.key, v);
+      }
+    }
+    
+    return Array.from(merged.values());
+  }
+
+  /**
+   * Get all environments and their variables
+   */
+  async getAllEnvironments() {
+    const result = {};
+    
+    for (const [env, _] of Object.entries(this.environments)) {
+      try {
+        result[env] = await this.readEnvFile(env);
+      } catch (error) {
+        console.error(`Error reading ${env} environment:`, error);
+        result[env] = [];
+      }
+    }
+    
+    return result;
+  }
+
+  /**
+   * Copy variables from one environment to another
+   */
+  async copyEnvironment(source, target, excludeSecrets = true) {
+    const sourceVars = await this.readEnvFile(source);
+    
+    const targetVars = sourceVars
+      .filter(v => !excludeSecrets || !v.isSecret)
+      .map(v => ({
+        ...v,
+        environment: target,
+        id: `${target}-${v.key}`
+      }));
+    
+    await this.writeEnvFile(target, targetVars);
+    
+    return targetVars;
+  }
+}
+
+export default EnvFileManager;

package/management-ui/server/utils/import-commonjs.js

@@ -0,0 +1,28 @@
+import { createRequire } from 'module';
+import { pathToFileURL } from 'url';
+
+/**
+ * Helper function to import CommonJS modules in an ES module environment
+ * @param {string} modulePath - The path to the CommonJS module
+ * @returns {Promise<any>} The imported module
+ */
+export async function importCommonJS(modulePath) {
+    try {
+        // First try dynamic import (works if the module supports ESM)
+        const moduleURL = pathToFileURL(modulePath).href;
+        return await import(moduleURL);
+    } catch (error) {
+        // If dynamic import fails, try using createRequire
+        try {
+            const require = createRequire(import.meta.url);
+            const module = require(modulePath);
+            // Wrap in an object to match ESM import structure
+            return { default: module, ...module };
+        } catch (requireError) {
+            console.error('Failed to import module:', modulePath);
+            console.error('Dynamic import error:', error.message);
+            console.error('Require error:', requireError.message);
+            throw new Error(`Unable to import module at ${modulePath}`);
+        }
+    }
+}

package/management-ui/server/utils/response.js

@@ -0,0 +1,83 @@
+/**
+ * Utility functions for creating standardized API responses
+ * Implements the API contract defined in api-contract.md
+ */
+
+/**
+ * Create a standardized success response
+ * @param {any} data - The response data
+ * @param {string} message - Optional success message
+ * @returns {object} Standardized success response
+ */
+export function createStandardResponse(data, message = null) {
+  return {
+    status: 'success',
+    data,
+    message,
+    timestamp: new Date().toISOString()
+  }
+}
+
+/**
+ * Create a standardized error response
+ * @param {string} code - Error code
+ * @param {string} message - Error message
+ * @param {any} details - Optional error details
+ * @returns {object} Standardized error response
+ */
+export function createErrorResponse(code, message, details = null) {
+  return {
+    status: 'error',
+    error: {
+      code,
+      message,
+      details
+    },
+    timestamp: new Date().toISOString()
+  }
+}
+
+/**
+ * Error codes for different types of errors
+ */
+export const ERROR_CODES = {
+  // General errors
+  INVALID_REQUEST: 'INVALID_REQUEST',
+  UNAUTHORIZED: 'UNAUTHORIZED',
+  FORBIDDEN: 'FORBIDDEN',
+  NOT_FOUND: 'NOT_FOUND',
+  INTERNAL_ERROR: 'INTERNAL_ERROR',
+  
+  // Project errors
+  PROJECT_NOT_FOUND: 'PROJECT_NOT_FOUND',
+  PROJECT_ALREADY_RUNNING: 'PROJECT_ALREADY_RUNNING',
+  PROJECT_NOT_RUNNING: 'PROJECT_NOT_RUNNING',
+  PROJECT_START_FAILED: 'PROJECT_START_FAILED',
+  PROJECT_STOP_FAILED: 'PROJECT_STOP_FAILED',
+  
+  // Integration errors
+  INTEGRATION_NOT_FOUND: 'INTEGRATION_NOT_FOUND',
+  INTEGRATION_ALREADY_INSTALLED: 'INTEGRATION_ALREADY_INSTALLED',
+  INTEGRATION_INSTALL_FAILED: 'INTEGRATION_INSTALL_FAILED',
+  INTEGRATION_CONFIG_INVALID: 'INTEGRATION_CONFIG_INVALID',
+  
+  // Environment errors
+  ENV_READ_FAILED: 'ENV_READ_FAILED',
+  ENV_WRITE_FAILED: 'ENV_WRITE_FAILED',
+  ENV_SYNC_FAILED: 'ENV_SYNC_FAILED',
+  
+  // CLI errors
+  CLI_COMMAND_FAILED: 'CLI_COMMAND_FAILED',
+  CLI_COMMAND_NOT_FOUND: 'CLI_COMMAND_NOT_FOUND'
+}
+
+/**
+ * Wrap async route handlers to catch errors automatically
+ * @param {Function} fn - Async route handler function
+ * @returns {Function} Wrapped function with error handling
+ */
+export function asyncHandler(fn) {
+  return (req, res, next) => {
+    Promise.resolve(fn(req, res, next)).catch(next)
+  }
+}