@tamyla/clodo-framework 3.1.22 → 3.1.24

package/dist/cli/commands/diagnose.js

@@ -0,0 +1,83 @@
+import chalk from 'chalk';
+import path from 'path';
+import { ServiceOrchestrator } from '../service-management/ServiceOrchestrator.js';
+import { StandardOptions } from '../lib/shared/utils/cli-options.js';
+import { ServiceConfigManager } from '../lib/shared/utils/service-config-manager.js';
+export function registerDiagnoseCommand(program) {
+  const command = program.command('diagnose [service-path]').description('Diagnose and report issues with an existing service').option('--deep-scan', 'Perform deep analysis including dependencies and deployment readiness').option('--export-report <file>', 'Export diagnostic report to file').option('--fix-suggestions', 'Include suggested fixes for issues').option('--show-config-sources', 'Display all configuration sources and merged result');
+
+  // Add standard options (--verbose, --quiet, --json, --no-color, --config-file)
+  StandardOptions.define(command).action(async (servicePath, options) => {
+    try {
+      const output = new (await import('../lib/shared/utils/output-formatter.js')).OutputFormatter(options);
+      const configManager = new ServiceConfigManager({
+        verbose: options.verbose,
+        quiet: options.quiet,
+        json: options.json,
+        showSources: options.showConfigSources
+      });
+      const orchestrator = new ServiceOrchestrator();
+
+      // Validate service path with better error handling
+      try {
+        servicePath = await configManager.validateServicePath(servicePath, orchestrator);
+      } catch (error) {
+        output.error(error.message);
+        if (error.suggestions) {
+          output.info('Suggestions:');
+          output.list(error.suggestions);
+        }
+        process.exit(1);
+      }
+
+      // Load and merge all configurations
+      const mergedOptions = await configManager.loadServiceConfig(servicePath, options, {
+        deepScan: false,
+        exportReport: null,
+        fixSuggestions: false
+      });
+      output.info('🔍 Diagnosing service...');
+      const diagnosis = await orchestrator.diagnoseService(servicePath, mergedOptions);
+
+      // Display results
+      output.section('Diagnostic Report');
+      output.list([`Service: ${diagnosis.serviceName || 'Unknown'}`, `Path: ${servicePath}`]);
+      if (diagnosis.errors.length > 0) {
+        output.warning('❌ Critical Errors:');
+        diagnosis.errors.forEach(error => {
+          let msg = `• ${error.message}`;
+          if (error.location) msg += ` (Location: ${error.location})`;
+          if (error.suggestion) msg += ` 💡 ${error.suggestion}`;
+          output.warning(msg);
+        });
+      }
+      if (diagnosis.warnings.length > 0) {
+        output.warning('⚠️  Warnings:');
+        diagnosis.warnings.forEach(warning => {
+          let msg = `• ${warning.message}`;
+          if (warning.suggestion) msg += ` 💡 ${warning.suggestion}`;
+          output.warning(msg);
+        });
+      }
+      if (diagnosis.recommendations.length > 0) {
+        output.info('💡 Recommendations:');
+        output.list(diagnosis.recommendations);
+      }
+
+      // Export report if requested
+      if (mergedOptions.exportReport) {
+        await orchestrator.exportDiagnosticReport(diagnosis, mergedOptions.exportReport);
+        output.success(`📄 Report exported to: ${mergedOptions.exportReport}`);
+      }
+
+      // Exit with error code if critical issues found
+      if (diagnosis.errors.length > 0) {
+        process.exit(1);
+      }
+    } catch (error) {
+      const output = new (await import('../lib/shared/utils/output-formatter.js')).OutputFormatter(options || {});
+      output.error(`Diagnosis failed: ${error.message}`);
+      process.exit(1);
+    }
+  });
+}

package/dist/{bin → cli}/commands/helpers/deployment-verification.js

@@ -3,8 +3,7 @@
  * Provides UI-specific deployment verification by delegating to shared infrastructure
  */
 
-import { verifyWorkerDeployment, healthCheckWithBackoff } from '../../shared/monitoring/health-checker.js';
-import { checkHealth } from '../../shared/monitoring/health-checker.js';
+import { verifyWorkerDeployment, healthCheckWithBackoff, checkHealth } from '../../lib/shared/monitoring/health-checker.js';
 import chalk from 'chalk';
 import readline from 'readline';
 
@@ -158,7 +157,7 @@ async function discoverUrlFromCloudflare(cloudflareSettings, options = {}) {
   try {
     const {
       CloudflareAPI
-    } = await import('../../../utils/cloudflare/api.js');
+    } = await import('../../utils/cloudflare/api.js');
     const api = new CloudflareAPI(cloudflareSettings.token);
 
     // Get worker routes for the zone

package/dist/{bin → cli}/commands/helpers/error-recovery.js

@@ -3,7 +3,7 @@
  * Provides interactive error recovery by delegating to shared error classification
  */
 
-import { classifyError, getRecoverySuggestions } from '../../shared/error-handling/error-classifier.js';
+import { classifyError, getRecoverySuggestions } from '../../lib/shared/error-handling/error-classifier.js';
 import chalk from 'chalk';
 import readline from 'readline';
 

package/dist/{bin → cli}/commands/helpers/resource-detection.js

@@ -22,7 +22,7 @@ export async function detectExistingResources(serviceName, manifest, credentials
     // Import CloudflareAPI to check existing resources
     const {
       CloudflareAPI
-    } = await import('../../../utils/cloudflare/api.js');
+    } = await import('../../utils/cloudflare/api.js');
     const cfApi = new CloudflareAPI(credentials.token);
 
     // Check if worker already exists

package/dist/cli/commands/helpers.js

@@ -0,0 +1,110 @@
+/**
+ * CLI Helpers - Shared utilities for all commands
+ */
+
+import chalk from 'chalk';
+import { existsSync, readFileSync } from 'fs';
+import { join, resolve } from 'path';
+
+/**
+ * Show progress indicator for deployment steps
+ */
+export function showProgress(message, duration = 2000) {
+  return new Promise(resolve => {
+    process.stdout.write(chalk.cyan(`⏳ ${message}...`));
+    const spinner = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    let i = 0;
+    const interval = setInterval(() => {
+      process.stdout.write(`\r${chalk.cyan(spinner[i])} ${message}...`);
+      i = (i + 1) % spinner.length;
+    }, 100);
+    setTimeout(() => {
+      clearInterval(interval);
+      process.stdout.write(`\r${chalk.green('✅')} ${message}... Done!\n`);
+      resolve();
+    }, duration);
+  });
+}
+
+/**
+ * Early validation function to check prerequisites before deployment
+ */
+export async function validateDeploymentPrerequisites(coreInputs, options) {
+  const issues = [];
+  console.log(chalk.cyan('\n🔍 Pre-deployment Validation'));
+  console.log(chalk.gray('─'.repeat(40)));
+
+  // Check required fields
+  if (!coreInputs.customer) {
+    issues.push('Customer name is required');
+  }
+  if (!coreInputs.environment) {
+    issues.push('Environment is required');
+  }
+  if (!coreInputs.domainName) {
+    issues.push('Domain name is required');
+  }
+  if (!coreInputs.cloudflareToken) {
+    issues.push('Cloudflare API token is required');
+  }
+
+  // Check Cloudflare token format (basic validation)
+  if (coreInputs.cloudflareToken && !coreInputs.cloudflareToken.startsWith('CLOUDFLARE_API_TOKEN=')) {
+    if (coreInputs.cloudflareToken.length < 40) {
+      issues.push('Cloudflare API token appears to be invalid (too short)');
+    }
+  }
+
+  // Check if service path exists
+  if (options.servicePath && options.servicePath !== '.') {
+    if (!existsSync(options.servicePath)) {
+      issues.push(`Service path does not exist: ${options.servicePath}`);
+    }
+  }
+
+  // Check for wrangler.toml if not dry run
+  if (!options.dryRun) {
+    const wranglerPath = join(options.servicePath || '.', 'wrangler.toml');
+    if (!existsSync(wranglerPath)) {
+      issues.push('wrangler.toml not found in service directory');
+    }
+  }
+
+  // Report issues
+  if (issues.length > 0) {
+    console.log(chalk.red('\n❌ Validation Failed:'));
+    issues.forEach(issue => {
+      console.log(chalk.red(`   • ${issue}`));
+    });
+    console.log(chalk.gray('\n─'.repeat(40)));
+    return false;
+  }
+  console.log(chalk.green('✅ All prerequisites validated'));
+  console.log(chalk.gray('─'.repeat(40)));
+  return true;
+}
+
+/**
+ * Redact sensitive information from logs
+ */
+export function redactSensitiveInfo(text) {
+  if (typeof text !== 'string') return text;
+
+  // Patterns to redact
+  const patterns = [
+  // Cloudflare API tokens
+  [/(CLOUDFLARE_API_TOKEN=?)(\w{20,})/gi, '$1[REDACTED]'],
+  // Generic API tokens/keys
+  [/(api[_-]?token|api[_-]?key|auth[_-]?token)["']?[:=]\s*["']?([a-zA-Z0-9_-]{20,})["']?/gi, '$1: [REDACTED]'],
+  // Passwords
+  [/(password|passwd|pwd)["']?[:=]\s*["']?([^"'\s]{3,})["']?/gi, '$1: [REDACTED]'],
+  // Secrets
+  [/(secret|key)["']?[:=]\s*["']?([a-zA-Z0-9_-]{10,})["']?/gi, '$1: [REDACTED]'],
+  // Account IDs (partial redaction)
+  [/(account[_-]?id|zone[_-]?id)["']?[:=]\s*["']?([a-zA-Z0-9]{8})([a-zA-Z0-9]{24,})["']?/gi, '$1: $2[REDACTED]']];
+  let redacted = text;
+  patterns.forEach(([pattern, replacement]) => {
+    redacted = redacted.replace(pattern, replacement);
+  });
+  return redacted;
+}

package/dist/cli/commands/init-config.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+
+/**
+ * Initialize Configuration Command
+ * Copies the framework's validation-config.json to the service directory for customization
+ */
+import { copyFile, access } from 'fs/promises';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import chalk from 'chalk';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Path to framework's bundled config
+const FRAMEWORK_CONFIG_PATH = join(__dirname, '../config/validation-config.json');
+
+/**
+ * Register the init-config command with the CLI
+ */
+export function registerInitConfigCommand(program) {
+  program.command('init-config').description('Initialize validation-config.json in your service directory').option('-f, --force', 'Overwrite existing validation-config.json', false).action(handler);
+}
+async function handler(options) {
+  const targetPath = join(process.cwd(), 'validation-config.json');
+  try {
+    // Check if file already exists
+    try {
+      await access(targetPath);
+      if (!options.force) {
+        console.log(chalk.yellow('⚠️  validation-config.json already exists.'));
+        console.log(chalk.gray('   Use --force to overwrite.'));
+        process.exit(0);
+      } else {
+        console.log(chalk.yellow('🔄 Overwriting existing validation-config.json...'));
+      }
+    } catch {
+      // File doesn't exist, proceed
+    }
+
+    // Copy framework config to service directory
+    await copyFile(FRAMEWORK_CONFIG_PATH, targetPath);
+    console.log(chalk.green('✅ Successfully initialized validation-config.json'));
+    console.log(chalk.gray('\n📝 Configuration file details:'));
+    console.log(chalk.gray(`   Location: ${targetPath}`));
+    console.log(chalk.gray('\n💡 Usage:'));
+    console.log(chalk.gray('   • Customize timing values (timeouts, intervals)'));
+    console.log(chalk.gray('   • Add service-specific endpoints for validation'));
+    console.log(chalk.gray('   • Configure platform-specific commands'));
+    console.log(chalk.gray('   • Set environment-specific requirements'));
+    console.log(chalk.gray('\n⚠️  Note: Most services don\'t need this file.'));
+    console.log(chalk.gray('   The framework provides sensible defaults.'));
+  } catch (error) {
+    console.error(chalk.red('❌ Failed to initialize configuration:'));
+    console.error(chalk.red(`   ${error.message}`));
+    process.exit(1);
+  }
+}

package/dist/cli/commands/update.js

@@ -0,0 +1,102 @@
+/**
+ * Update Command - Update an existing service configuration
+ */
+
+import chalk from 'chalk';
+import path from 'path';
+import { ServiceOrchestrator } from '../service-management/ServiceOrchestrator.js';
+import { StandardOptions } from '../lib/shared/utils/cli-options.js';
+import { ServiceConfigManager } from '../lib/shared/utils/service-config-manager.js';
+export function registerUpdateCommand(program) {
+  const command = program.command('update [service-path]').description('Update an existing service configuration').option('-i, --interactive', 'Run in interactive mode to select what to update').option('--domain-name <domain>', 'Update domain name').option('--cloudflare-token <token>', 'Update Cloudflare API token').option('--cloudflare-account-id <id>', 'Update Cloudflare account ID').option('--cloudflare-zone-id <id>', 'Update Cloudflare zone ID').option('--environment <env>', 'Update target environment: development, staging, production').option('--add-feature <feature>', 'Add a feature flag').option('--remove-feature <feature>', 'Remove a feature flag').option('--regenerate-configs', 'Regenerate all configuration files').option('--fix-errors', 'Attempt to fix common configuration errors').option('--preview', 'Show what would be changed without applying').option('--show-config-sources', 'Display all configuration sources and merged result').option('--force', 'Skip confirmation prompts');
+
+  // Add standard options (--verbose, --quiet, --json, --no-color, --config-file)
+  StandardOptions.define(command).action(async (servicePath, options) => {
+    try {
+      const output = new (await import('../lib/shared/utils/output-formatter.js')).OutputFormatter(options);
+      const configManager = new ServiceConfigManager({
+        verbose: options.verbose,
+        quiet: options.quiet,
+        json: options.json,
+        showSources: options.showConfigSources
+      });
+      const orchestrator = new ServiceOrchestrator();
+
+      // Auto-detect service path if not provided
+      if (!servicePath) {
+        servicePath = await orchestrator.detectServicePath();
+        if (!servicePath) {
+          output.error('No service path provided and could not auto-detect service directory');
+          process.exit(1);
+        }
+      }
+
+      // Validate service path with better error handling
+      try {
+        servicePath = await configManager.validateServicePath(servicePath, orchestrator);
+      } catch (error) {
+        output.error(error.message);
+        if (error.suggestions) {
+          output.info('Suggestions:');
+          output.list(error.suggestions);
+        }
+        process.exit(1);
+      }
+
+      // Load and merge all configurations
+      const mergedOptions = await configManager.loadServiceConfig(servicePath, options, {
+        interactive: false,
+        domainName: null,
+        cloudflareToken: null,
+        cloudflareAccountId: null,
+        cloudflareZoneId: null,
+        environment: null,
+        addFeature: null,
+        removeFeature: null,
+        regenerateConfigs: false,
+        fixErrors: false,
+        preview: false,
+        force: false
+      });
+      if (!servicePath) {
+        servicePath = await orchestrator.detectServicePath();
+        if (!servicePath) {
+          output.error('No service path provided and could not auto-detect service directory');
+          output.info('Please run this command from within a service directory or specify the path');
+          process.exit(1);
+        }
+        output.info(`Auto-detected service at: ${servicePath}`);
+      }
+
+      // Validate it's a service directory
+      const isValid = await orchestrator.validateService(servicePath, {
+        customConfig: mergedOptions
+      });
+      if (!isValid.valid) {
+        output.warning('Service has configuration issues. Use --fix-errors to attempt automatic fixes.');
+        if (!mergedOptions.fixErrors) {
+          output.info('Issues found:');
+          output.list(isValid.issues || []);
+          process.exit(1);
+        }
+      }
+      if (mergedOptions.interactive) {
+        await orchestrator.runInteractiveUpdate(servicePath);
+      } else {
+        await orchestrator.runNonInteractiveUpdate(servicePath, mergedOptions);
+      }
+      output.success('Service update completed successfully!');
+    } catch (error) {
+      const output = new (await import('../lib/shared/utils/output-formatter.js')).OutputFormatter(options || {});
+      output.error(`Service update failed: ${error.message}`);
+      if (error.details) {
+        output.warning(`Details: ${error.details}`);
+      }
+      if (error.recovery) {
+        output.info('Recovery suggestions:');
+        output.list(error.recovery);
+      }
+      process.exit(1);
+    }
+  });
+}

package/dist/cli/commands/validate.js

@@ -0,0 +1,65 @@
+/**
+ * Validate Command - Validate an existing service configuration
+ */
+
+import chalk from 'chalk';
+import path from 'path';
+import { ServiceOrchestrator } from '../service-management/ServiceOrchestrator.js';
+import { StandardOptions } from '../lib/shared/utils/cli-options.js';
+import { ServiceConfigManager } from '../lib/shared/utils/service-config-manager.js';
+export function registerValidateCommand(program) {
+  const command = program.command('validate <service-path>').description('Validate an existing service configuration').option('--deep-scan', 'Run comprehensive validation checks').option('--export-report <file>', 'Export validation report to JSON file').option('--show-config-sources', 'Display all configuration sources and merged result');
+
+  // Add standard options (--verbose, --quiet, --json, --no-color, --config-file)
+  StandardOptions.define(command).action(async (servicePath, options) => {
+    try {
+      const output = new (await import('../lib/shared/utils/output-formatter.js')).OutputFormatter(options);
+      const configManager = new ServiceConfigManager({
+        verbose: options.verbose,
+        quiet: options.quiet,
+        json: options.json,
+        showSources: options.showConfigSources
+      });
+      const orchestrator = new ServiceOrchestrator();
+
+      // Validate service path with better error handling
+      try {
+        servicePath = await configManager.validateServicePath(servicePath, orchestrator);
+      } catch (error) {
+        output.error(error.message);
+        if (error.suggestions) {
+          output.info('Suggestions:');
+          output.list(error.suggestions);
+        }
+        process.exit(1);
+      }
+
+      // Load and merge all configurations
+      const mergedOptions = await configManager.loadServiceConfig(servicePath, options, {
+        deepScan: false,
+        exportReport: null
+      });
+      const result = await orchestrator.validateService(servicePath, {
+        deepScan: mergedOptions.deepScan,
+        exportReport: mergedOptions.exportReport,
+        customConfig: mergedOptions.validation // Pass custom validation config
+      });
+      if (result.valid) {
+        output.success('Service configuration is valid');
+      } else {
+        output.error('Service configuration has issues:');
+        output.list(result.issues || []);
+        process.exit(1);
+      }
+
+      // Report export success if requested
+      if (mergedOptions.exportReport) {
+        output.success(`📄 Report exported to: ${mergedOptions.exportReport}`);
+      }
+    } catch (error) {
+      const output = new (await import('../lib/shared/utils/output-formatter.js')).OutputFormatter(options || {});
+      output.error(`Validation failed: ${error.message}`);
+      process.exit(1);
+    }
+  });
+}

package/dist/cli/security-cli.js

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+import { SecurityCLI } from '../security/SecurityCLI.js';
+const command = process.argv[2];
+const args = process.argv.slice(3);
+async function main() {
+  const cli = new SecurityCLI();
+  switch (command) {
+    case 'validate':
+      {
+        const [customer, environment] = args;
+        const result = await cli.validateConfiguration(customer, environment);
+        if (result.valid) {
+          console.log('✅ Security validation passed');
+        } else {
+          console.log('❌ Security issues found');
+          result.securityIssues.forEach(issue => {
+            console.log(`   ${issue.severity.toUpperCase()}: ${issue.message}`);
+          });
+        }
+        process.exit(result.valid ? 0 : 1);
+        break;
+      }
+    case 'generate-key':
+      {
+        const [type, lengthStr] = args;
+        const length = lengthStr ? parseInt(lengthStr) : undefined;
+        const keyResult = cli.generateKey(type, length);
+        if (keyResult.success) {
+          console.log(`Generated ${keyResult.type}: ${keyResult.key}`);
+        } else {
+          console.error(`Key generation failed: ${keyResult.error}`);
+          process.exit(1);
+        }
+        break;
+      }
+    case 'deploy':
+      {
+        // Check for help flag first
+        if (args.includes('--help') || args.includes('-h')) {
+          console.log('Deploy with security validation');
+          console.log('');
+          console.log('Usage:');
+          console.log('  clodo-security deploy <customer> <environment> [options]');
+          console.log('');
+          console.log('Arguments:');
+          console.log('  customer      Customer name (e.g., wetechfounders)');
+          console.log('  environment   Target environment (development, staging, production)');
+          console.log('');
+          console.log('Options:');
+          console.log('  --dry-run     Simulate deployment without making changes');
+          console.log('  --help, -h    Display this help message');
+          console.log('');
+          console.log('Examples:');
+          console.log('  clodo-security deploy wetechfounders development');
+          console.log('  clodo-security deploy greatidude production --dry-run');
+          break;
+        }
+        const [deployCustomer, deployEnvironment] = args.filter(arg => !arg.startsWith('--'));
+        const dryRun = args.includes('--dry-run');
+        const deployResult = await cli.deployWithSecurity(deployCustomer, deployEnvironment, {
+          dryRun
+        });
+        if (deployResult.success) {
+          console.log(`✅ Deployment ${dryRun ? 'validation' : 'completed'} successfully`);
+        } else {
+          console.error(`Deployment failed: ${deployResult.error}`);
+          process.exit(1);
+        }
+        break;
+      }
+    case 'generate-config':
+      {
+        const [configCustomer, configEnvironment] = args;
+        const configResult = cli.generateSecureConfig(configCustomer, configEnvironment);
+        if (configResult.success) {
+          console.log('Generated secure configuration:');
+          console.log(JSON.stringify(configResult.config, null, 2));
+        } else {
+          console.error(`Config generation failed: ${configResult.error}`);
+          process.exit(1);
+        }
+        break;
+      }
+    case 'check-readiness':
+      {
+        const [readyCustomer, readyEnvironment] = args;
+        const readinessResult = cli.checkDeploymentReadiness(readyCustomer, readyEnvironment);
+        if (readinessResult.ready) {
+          console.log('✅ Deployment ready');
+        } else {
+          console.log('❌ Deployment not ready:');
+          readinessResult.issues.forEach(issue => console.log(`   - ${issue}`));
+          process.exit(1);
+        }
+        break;
+      }
+    default:
+      console.log('Clodo Framework Security CLI');
+      console.log('');
+      console.log('Commands:');
+      console.log('  validate <customer> <environment>    - Validate configuration security');
+      console.log('  generate-key [type] [length]         - Generate secure key (api/jwt)');
+      console.log('  deploy <customer> <environment>      - Deploy with security validation');
+      console.log('  generate-config <customer> <env>     - Generate secure configuration');
+      console.log('  check-readiness <customer> <env>     - Check deployment readiness');
+      console.log('');
+      console.log('Examples:');
+      console.log('  clodo-security validate tamyla production');
+      console.log('  clodo-security generate-key jwt 64');
+      console.log('  clodo-security generate-key content-skimmer');
+      console.log('  clodo-security deploy tamyla staging --dry-run');
+      break;
+  }
+}
+main().catch(error => {
+  console.error(`Unexpected error: ${error.message}`);
+  process.exit(1);
+});

package/dist/config/FeatureManager.js

@@ -0,0 +1,6 @@
+/**
+ * Feature Manager
+ * Alias for features.js to maintain compatibility
+ */
+
+export * from './features.js';

package/dist/config/clodo-create.example.json

@@ -0,0 +1,26 @@
+{
+  "// Comment": "Example configuration for 'npx clodo-service create' command",
+  "// Instructions": "Copy this file and customize for your needs, then use: npx clodo-service create --config-file your-config.json",
+  "// CLI Override": "Any CLI options passed on command line will override values from this config file",
+  
+  "projectName": "my-cloudflare-worker",
+  "description": "A sample Cloudflare Worker project",
+  "environment": "development",
+  "region": "us-west-1",
+  "template": "basic",
+  "typescript": true,
+  "installDependencies": true,
+  
+  "advanced": {
+    "nodeVersion": "18.x",
+    "packageManager": "npm",
+    "outputDir": "./dist",
+    "sourceDir": "./src"
+  },
+  
+  "metadata": {
+    "author": "your-name",
+    "license": "MIT",
+    "version": "0.1.0"
+  }
+}

package/dist/config/clodo-deploy.example.json

@@ -0,0 +1,41 @@
+{
+  "// Comment": "Example configuration for 'npx clodo-service deploy' command",
+  "// Instructions": "Copy this file and customize for your needs, then use: npx clodo-service deploy --config-file your-config.json",
+  "// EnvVars": "You can use environment variable substitution: ${ENV_VAR_NAME} will be replaced with the value of ENV_VAR_NAME",
+  
+  "domain": "api.example.com",
+  "environment": "production",
+  "cloudflareToken": "${CLOUDFLARE_TOKEN}",
+  "cloudflareZoneId": "${CLOUDFLARE_ZONE_ID}",
+  
+  "deployment": {
+    "strategy": "blue-green",
+    "replicas": 3,
+    "maxConcurrency": 100,
+    "timeout": 30000,
+    "healthCheckInterval": 5000,
+    "rollbackOnFailure": true
+  },
+  
+  "routing": {
+    "enableLoadBalancing": true,
+    "loadBalancingPolicy": "round-robin",
+    "corsEnabled": true,
+    "corsOrigins": ["https://example.com", "https://app.example.com"]
+  },
+  
+  "monitoring": {
+    "enableMetrics": true,
+    "metricsEndpoint": "https://metrics.example.com",
+    "alertOnFailure": true,
+    "alertEmail": "alerts@example.com"
+  },
+  
+  "security": {
+    "enableSSL": true,
+    "minTLSVersion": "1.2",
+    "enableWAF": true,
+    "rateLimit": 1000,
+    "rateLimitWindow": 60
+  }
+}