@tamyla/clodo-framework 1.0.0

package/bin/shared/config/customer-cli.js

@@ -0,0 +1,293 @@
+#!/usr/bin/env node
+
+/**
+ * Customer Configuration Management CLI
+ * Manages multi-environment, multi-customer configuration structure
+ * Integrates with Clodo Framework domain and feature flag systems
+ */
+
+import { CustomerConfigCLI } from '../../../src/config/CustomerConfigCLI.js';
+
+const command = process.argv[2];
+const args = process.argv.slice(3);
+
+async function main() {
+  const cli = new CustomerConfigCLI();
+  await cli.initialize();
+
+  try {
+    switch (command) {
+      case 'create-customer':
+        const [customerName, domain] = args;
+        const result = await cli.createCustomer(customerName, domain);
+        if (result.success) {
+          console.log(`\n🎉 Customer ${customerName} configuration created successfully!`);
+          console.log(`\n📋 Customer Details:`);
+          console.log(`   Name: ${result.customer.name}`);
+          console.log(`   Domain: ${result.customer.domain || 'Not specified'}`);
+          console.log(`   Config Path: ${result.customer.configPath}`);
+          console.log(`   Environments: ${result.customer.environments.join(', ')}`);
+          console.log(`\n📋 Next steps:`);
+          console.log(`1. Review generated configs in: config/customers/${customerName}/`);
+          console.log(`2. Update domain-specific URLs if needed`);
+          console.log(`3. Generate production secrets: npm run security:generate-key ${customerName}`);
+          console.log(`4. Set production secrets: wrangler secret put KEY_NAME --env production`);
+        } else {
+          console.error(`❌ Failed to create customer: ${result.error}`);
+          process.exit(1);
+        }
+        break;
+
+      case 'validate':
+        const validateResult = await cli.validateConfigurations();
+        if (validateResult.valid) {
+          console.log('✅ All customer configurations are valid');
+        } else {
+          console.log('❌ Configuration validation failed');
+          validateResult.errors.forEach(error => console.log(`   - ${error}`));
+          process.exit(1);
+        }
+        break;
+
+      case 'show':
+        const [customerNameShow, environment] = args;
+        const showResult = cli.showConfiguration(customerNameShow, environment);
+        if (showResult.success) {
+          console.log(`🔍 Effective configuration: ${customerNameShow}/${environment}\n`);
+          if (showResult.config.variables?.base) {
+            console.log('📋 Base variables:');
+            Object.entries(showResult.config.variables.base).slice(0, 10).forEach(([key, value]) => {
+              console.log(`   ${key}=${value}`);
+            });
+            if (Object.keys(showResult.config.variables.base).length > 10) {
+              console.log('   ...');
+            }
+            console.log('');
+          }
+          if (showResult.config.variables?.customer) {
+            console.log(`📋 Customer ${environment} variables:`);
+            Object.entries(showResult.config.variables.customer).slice(0, 15).forEach(([key, value]) => {
+              console.log(`   ${key}=${value}`);
+            });
+            if (Object.keys(showResult.config.variables.customer).length > 15) {
+              console.log('   ...');
+            }
+            console.log('');
+          }
+          if (showResult.config.features && Object.keys(showResult.config.features).length > 0) {
+            console.log('🚩 Customer features:');
+            Object.entries(showResult.config.features).forEach(([feature, enabled]) => {
+              console.log(`   ${feature}: ${enabled ? '✅' : '❌'}`);
+            });
+          }
+        } else {
+          console.error(`❌ Failed to show configuration: ${showResult.error}`);
+          process.exit(1);
+        }
+        break;
+
+      case 'deploy-command':
+        const [customerNameDeploy, environmentDeploy] = args;
+        const deployResult = cli.getDeployCommand(customerNameDeploy, environmentDeploy);
+        if (deployResult.success) {
+          console.log(`📋 Deploy command for ${customerNameDeploy}/${environmentDeploy}:`);
+          console.log(`   ${deployResult.command}`);
+          console.log(`\n💡 Ensure customer config is loaded: ${deployResult.configPath}`);
+        } else {
+          console.error(`❌ Failed to get deploy command: ${deployResult.error}`);
+          process.exit(1);
+        }
+        break;
+
+      case 'list':
+        const listResult = cli.listCustomers();
+        if (listResult.success && listResult.customers.length > 0) {
+          console.log('📋 Configured customers:\n');
+          listResult.customers.forEach(customer => {
+            console.log(`🏢 ${customer.name}`);
+            console.log(`   Domain: ${customer.domain || 'Not specified'}`);
+            console.log(`   Environments: ${customer.environments.join(', ')}`);
+            console.log(`   Created: ${customer.createdAt}`);
+            console.log(`   Config: config/customers/${customer.name}/`);
+            console.log('');
+          });
+        } else if (listResult.success) {
+          console.log('📋 No customers configured');
+        } else {
+          console.error(`❌ Failed to list customers: ${listResult.error}`);
+          process.exit(1);
+        }
+        break;
+
+      default:
+        console.log('Customer Configuration Management Tool\n');
+        console.log('Available commands:');
+        console.log('  create-customer <name> [domain]  - Create new customer config from template');
+        console.log('  validate                         - Validate configuration structure');
+        console.log('  show <customer> <environment>    - Show effective configuration');
+        console.log('  deploy-command <customer> <env>  - Get deployment command');
+        console.log('  list                             - List all configured customers');
+        console.log('\nExamples:');
+        console.log('  clodo-customer-config create-customer acmecorp acmecorp.com');
+        console.log('  clodo-customer-config validate');
+        console.log('  clodo-customer-config show acmecorp production');
+        console.log('  clodo-customer-config list');
+        console.log('\nIntegration:');
+        console.log('  This tool integrates with Clodo Framework domain and feature flag systems.');
+        console.log('  Customer configurations are automatically registered as domains.');
+        break;
+    }
+  } catch (error) {
+    console.error(`❌ Error: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+main().catch(error => {
+  console.error(`❌ Unexpected error: ${error.message}`);
+  process.exit(1);
+});
+
+async function handleCreateCustomer(args) {
+  const [customerName, domain] = args;
+
+  if (!customerName) {
+    console.error('Usage: customer-config create-customer <customer-name> [domain]');
+    process.exit(1);
+  }
+
+  console.log(`🏗️ Creating customer configuration: ${customerName}`);
+
+  // Pass framework mode flag to skip strict validation
+  const customerInfo = await customerManager.createCustomer(customerName, domain, {
+    skipValidation: true,
+    isFrameworkMode: true
+  });
+
+  console.log(`\n🎉 Customer ${customerName} configuration created successfully!`);
+  console.log(`\n📋 Customer Details:`);
+  console.log(`   Name: ${customerInfo.name}`);
+  console.log(`   Domain: ${customerInfo.domain || 'Not specified'}`);
+  console.log(`   Config Path: ${customerInfo.configPath}`);
+  console.log(`   Environments: ${customerInfo.environments.join(', ')}`);
+
+  console.log(`\n📋 Next steps:`);
+  console.log(`1. Review generated configs in: config/customers/${customerName}/`);
+  console.log(`2. Update domain-specific URLs if needed`);
+  console.log(`3. Generate production secrets: npm run security:generate-key ${customerName}`);
+  console.log(`4. Set production secrets: wrangler secret put KEY_NAME --env production`);
+}
+
+async function handleValidate() {
+  console.log('🔍 Validating customer configuration structure...\n');
+
+  const result = await customerManager.validateConfigs();
+
+  if (result.valid) {
+    console.log('✅ All customer configurations are valid');
+  } else {
+    console.log('❌ Configuration validation failed');
+    result.errors.forEach(error => console.log(`   - ${error}`));
+    process.exit(1);
+  }
+}
+
+async function handleShow(args) {
+  const [customerName, environment] = args;
+
+  if (!customerName || !environment) {
+    console.error('Usage: customer-config show <customer> <environment>');
+    process.exit(1);
+  }
+
+  const config = customerManager.showConfig(customerName, environment);
+
+  console.log(`🔍 Effective configuration: ${customerName}/${environment}\n`);
+
+  if (config.variables.base) {
+    console.log('📋 Base variables:');
+    Object.entries(config.variables.base).slice(0, 10).forEach(([key, value]) => {
+      console.log(`   ${key}=${value}`);
+    });
+    if (Object.keys(config.variables.base).length > 10) {
+      console.log('   ...');
+    }
+    console.log('');
+  }
+
+  if (config.variables.customer) {
+    console.log(`📋 Customer ${environment} variables:`);
+    Object.entries(config.variables.customer).slice(0, 15).forEach(([key, value]) => {
+      console.log(`   ${key}=${value}`);
+    });
+    if (Object.keys(config.variables.customer).length > 15) {
+      console.log('   ...');
+    }
+    console.log('');
+  }
+
+  if (config.features && Object.keys(config.features).length > 0) {
+    console.log('🚩 Customer features:');
+    Object.entries(config.features).forEach(([feature, enabled]) => {
+      console.log(`   ${feature}: ${enabled ? '✅' : '❌'}`);
+    });
+  }
+}
+
+async function handleDeployCommand(args) {
+  const [customerName, environment] = args;
+
+  if (!customerName || !environment) {
+    console.error('Usage: customer-config deploy-command <customer> <environment>');
+    process.exit(1);
+  }
+
+  const deployInfo = customerManager.getDeployCommand(customerName, environment);
+
+  console.log(`📋 Deploy command for ${customerName}/${environment}:`);
+  console.log(`   ${deployInfo.command}`);
+  console.log(`\n💡 Ensure customer config is loaded: ${deployInfo.configPath}`);
+}
+
+async function handleList() {
+  const customers = customerManager.listCustomers();
+
+  if (customers.length === 0) {
+    console.log('📋 No customers configured');
+    return;
+  }
+
+  console.log('📋 Configured customers:\n');
+
+  customers.forEach(customer => {
+    console.log(`🏢 ${customer.name}`);
+    console.log(`   Domain: ${customer.domain || 'Not specified'}`);
+    console.log(`   Environments: ${customer.environments.join(', ')}`);
+    console.log(`   Created: ${customer.createdAt}`);
+    console.log(`   Config: config/customers/${customer.name}/`);
+    console.log('');
+  });
+}
+
+function showHelp() {
+  console.log('Customer Configuration Management Tool\n');
+  console.log('Available commands:');
+  console.log('  create-customer <name> [domain]  - Create new customer config from template');
+  console.log('  validate                         - Validate configuration structure');
+  console.log('  show <customer> <environment>    - Show effective configuration');
+  console.log('  deploy-command <customer> <env>  - Get deployment command');
+  console.log('  list                             - List all configured customers');
+  console.log('\nExamples:');
+  console.log('  customer-config create-customer acmecorp acmecorp.com');
+  console.log('  customer-config validate');
+  console.log('  customer-config show acmecorp production');
+  console.log('  customer-config list');
+  console.log('\nIntegration:');
+  console.log('  This tool integrates with Clodo Framework domain and feature flag systems.');
+  console.log('  Customer configurations are automatically registered as domains.');
+}
+
+main().catch(error => {
+  console.error(`❌ Unexpected error: ${error.message}`);
+  process.exit(1);
+});

package/dist/config/ConfigurationManager.js

@@ -0,0 +1,159 @@
+/**
+ * Interactive Deployment Configuration Manager
+ * User input-driven configuration setup for deployment workflows
+ */
+
+import { askChoice, askUser } from '../utils/deployment/interactive-prompts.js';
+export class InteractiveDeploymentConfigurator {
+  /**
+   * Generate configuration from user input
+   * @param {Object} defaults - Default values
+   * @returns {Promise<Object>} User-configured settings
+   */
+  static async generateFromUserInput(defaults = {}) {
+    console.log('🔧 Configuration Setup');
+    console.log('======================');
+    const config = {
+      ...defaults
+    };
+
+    // Environment selection
+    config.environment = await askChoice('Select deployment environment:', ['development', 'staging', 'production'], 2 // Default to production
+    );
+
+    // Customer/domain input
+    config.customer = await askUser('Enter customer name:', defaults.customer || '');
+    config.domain = await askUser('Enter domain:', defaults.domain || '');
+
+    // Security settings
+    config.enableSecurityValidation = (await askChoice('Enable security validation?', ['yes', 'no'], 0)) === 'yes';
+
+    // Deployment options
+    config.runTests = (await askChoice('Run post-deployment tests?', ['yes', 'no'], 0)) === 'yes';
+
+    // Additional deployment settings
+    config.dryRun = (await askChoice('Perform dry run first?', ['yes', 'no'], 1 // Default to no
+    )) === 'yes';
+    config.allowInsecure = (await askChoice('Allow insecure deployment (not recommended)?', ['yes', 'no'], 1 // Default to no
+    )) === 'yes';
+    return config;
+  }
+
+  /**
+   * Validate user-provided configuration
+   * @param {Object} config - Configuration to validate
+   * @returns {Object} Validation result
+   */
+  static validateConfiguration(config) {
+    const errors = [];
+    const warnings = [];
+    if (!config.customer) {
+      errors.push('Customer name is required');
+    } else if (config.customer.length < 2) {
+      errors.push('Customer name must be at least 2 characters');
+    }
+    if (!config.domain) {
+      errors.push('Domain is required');
+    } else if (!this.isValidDomain(config.domain)) {
+      errors.push('Domain format is invalid');
+    }
+    if (!['development', 'staging', 'production'].includes(config.environment)) {
+      errors.push('Invalid environment selection');
+    }
+
+    // Warnings for potentially risky settings
+    if (config.allowInsecure) {
+      warnings.push('Insecure deployment allowed - security validations will be bypassed');
+    }
+    if (!config.enableSecurityValidation) {
+      warnings.push('Security validation disabled - deployment may be vulnerable');
+    }
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings,
+      hasWarnings: warnings.length > 0
+    };
+  }
+
+  /**
+   * Validate domain format
+   * @param {string} domain - Domain to validate
+   * @returns {boolean} True if valid domain format
+   */
+  static isValidDomain(domain) {
+    // Basic domain validation regex
+    const domainRegex = /^[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+    return domainRegex.test(domain);
+  }
+
+  /**
+   * Generate deployment URL from configuration
+   * @param {Object} config - Configuration object
+   * @returns {string} Generated deployment URL
+   */
+  static generateDeploymentUrl(config) {
+    const {
+      customer,
+      environment,
+      domain
+    } = config;
+    if (domain) {
+      return `https://${customer}.${domain}`;
+    }
+
+    // Fallback to Cloudflare Workers pattern
+    return `https://${customer}-${environment}.workers.dev`;
+  }
+
+  /**
+   * Create deployment configuration summary
+   * @param {Object} config - Configuration object
+   * @returns {string} Formatted configuration summary
+   */
+  static createConfigurationSummary(config) {
+    const lines = ['📋 Deployment Configuration Summary', '====================================', '', `👤 Customer: ${config.customer}`, `🌍 Environment: ${config.environment}`, `🔗 Domain: ${config.domain || 'Auto-generated'}`, `🔒 Security Validation: ${config.enableSecurityValidation ? 'Enabled' : 'Disabled'}`, `🧪 Post-deployment Tests: ${config.runTests ? 'Enabled' : 'Disabled'}`, `🧪 Dry Run: ${config.dryRun ? 'Yes' : 'No'}`, `⚠️  Allow Insecure: ${config.allowInsecure ? 'Yes' : 'No'}`, '', `🚀 Deployment URL: ${this.generateDeploymentUrl(config)}`];
+    return lines.join('\n');
+  }
+
+  /**
+   * Interactive configuration wizard
+   * @param {Object} defaults - Default configuration values
+   * @returns {Promise<Object>} Complete configuration object
+   */
+  static async runConfigurationWizard(defaults = {}) {
+    console.log('\n🚀 CLODO Framework Deployment Configuration Wizard');
+    console.log('================================================\n');
+    let config;
+    let isValid = false;
+    do {
+      config = await this.generateFromUserInput(defaults);
+      const validation = this.validateConfiguration(config);
+      if (!validation.valid) {
+        console.log('\n❌ Configuration Validation Failed:');
+        validation.errors.forEach(error => console.log(`   - ${error}`));
+        console.log('\nPlease correct the errors and try again.\n');
+        continue;
+      }
+      if (validation.hasWarnings) {
+        console.log('\n⚠️  Configuration Warnings:');
+        validation.warnings.forEach(warning => console.log(`   - ${warning}`));
+        const proceed = await askChoice('\nProceed with deployment despite warnings?', ['yes', 'no'], 1 // Default to no
+        );
+        if (proceed === 'no') {
+          console.log('Configuration cancelled. Please adjust settings.\n');
+          continue;
+        }
+      }
+      isValid = true;
+    } while (!isValid);
+    console.log('\n✅ Configuration Complete!');
+    console.log(this.createConfigurationSummary(config));
+    const confirm = await askChoice('\nDeploy with this configuration?', ['yes', 'no'], 0 // Default to yes
+    );
+    if (confirm === 'no') {
+      throw new Error('Deployment cancelled by user');
+    }
+    return config;
+  }
+}

package/dist/config/CustomerConfigCLI.js

@@ -0,0 +1,220 @@
+/**
+ * Clodo Framework - Customer Configuration CLI
+ * Programmatic API for customer configuration management
+ */
+
+import { CustomerConfigurationManager } from '../config/customers.js';
+export class CustomerConfigCLI {
+  constructor() {
+    this.customerManager = new CustomerConfigurationManager();
+  }
+
+  /**
+   * Initialize the customer manager by loading existing customers
+   * @returns {Promise<Object>} Initialization result
+   */
+  async initialize() {
+    try {
+      await this.customerManager.loadExistingCustomers();
+      return {
+        success: true,
+        message: 'Customer manager initialized successfully'
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Create a new customer configuration
+   * @param {string} customerName - Customer name
+   * @param {string} domain - Customer domain (optional)
+   * @param {Object} options - Creation options
+   * @returns {Promise<Object>} Creation result
+   */
+  async createCustomer(customerName, domain, options = {}) {
+    try {
+      if (!customerName) {
+        throw new Error('Customer name is required');
+      }
+      const customerInfo = await this.customerManager.createCustomer(customerName, domain, {
+        skipValidation: true,
+        isFrameworkMode: true,
+        ...options
+      });
+      return {
+        success: true,
+        customer: customerInfo
+      };
+    } catch (error) {
+      return {
+        success: false,
+        customerName,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Validate customer configuration structure
+   * @returns {Promise<Object>} Validation result
+   */
+  async validateConfigurations() {
+    try {
+      const result = await this.customerManager.validateConfigs();
+      return {
+        success: result.valid,
+        valid: result.valid,
+        errors: result.errors || []
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Show effective configuration for a customer and environment
+   * @param {string} customerName - Customer name
+   * @param {string} environment - Environment name
+   * @returns {Object} Configuration display result
+   */
+  showConfiguration(customerName, environment) {
+    try {
+      if (!customerName || !environment) {
+        throw new Error('Customer name and environment are required');
+      }
+      const config = this.customerManager.showConfig(customerName, environment);
+      return {
+        success: true,
+        customer: customerName,
+        environment,
+        config
+      };
+    } catch (error) {
+      return {
+        success: false,
+        customer: customerName,
+        environment,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Get deployment command for a customer and environment
+   * @param {string} customerName - Customer name
+   * @param {string} environment - Environment name
+   * @returns {Object} Deployment command result
+   */
+  getDeployCommand(customerName, environment) {
+    try {
+      if (!customerName || !environment) {
+        throw new Error('Customer name and environment are required');
+      }
+      const deployInfo = this.customerManager.getDeployCommand(customerName, environment);
+      return {
+        success: true,
+        customer: customerName,
+        environment,
+        command: deployInfo.command,
+        configPath: deployInfo.configPath
+      };
+    } catch (error) {
+      return {
+        success: false,
+        customer: customerName,
+        environment,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * List all configured customers
+   * @returns {Object} Customer list result
+   */
+  listCustomers() {
+    try {
+      const customers = this.customerManager.listCustomers();
+      return {
+        success: true,
+        customers
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Get available commands
+   * @returns {string[]} Array of available commands
+   */
+  getAvailableCommands() {
+    return ['create-customer', 'validate', 'show', 'deploy-command', 'list'];
+  }
+
+  /**
+   * Get command help
+   * @param {string} command - Command name (optional)
+   * @returns {string} Help text
+   */
+  getHelp(command) {
+    const help = {
+      'create-customer': 'create-customer <name> [domain] - Create new customer config from template',
+      'validate': 'validate - Validate configuration structure',
+      'show': 'show <customer> <environment> - Show effective configuration',
+      'deploy-command': 'deploy-command <customer> <environment> - Get deployment command',
+      'list': 'list - List all configured customers'
+    };
+    if (command && help[command]) {
+      return help[command];
+    }
+    return `Customer Configuration Management Tool
+
+Available commands:
+${Object.values(help).map(cmd => `  ${cmd}`).join('\n')}
+
+Examples:
+  create-customer acmecorp acmecorp.com
+  validate
+  show acmecorp production
+  list
+
+Integration:
+  This tool integrates with Clodo Framework domain and feature flag systems.
+  Customer configurations are automatically registered as domains.`;
+  }
+}
+
+// Convenience functions for direct use
+export async function createCustomer(customerName, domain, options = {}) {
+  const cli = new CustomerConfigCLI();
+  await cli.initialize();
+  return await cli.createCustomer(customerName, domain, options);
+}
+export async function validateCustomerConfigs() {
+  const cli = new CustomerConfigCLI();
+  await cli.initialize();
+  return await cli.validateConfigurations();
+}
+export function showCustomerConfig(customerName, environment) {
+  const cli = new CustomerConfigCLI();
+  return cli.showConfiguration(customerName, environment);
+}
+export function getCustomerDeployCommand(customerName, environment) {
+  const cli = new CustomerConfigCLI();
+  return cli.getDeployCommand(customerName, environment);
+}
+export function listConfiguredCustomers() {
+  const cli = new CustomerConfigCLI();
+  return cli.listCustomers();
+}