@tamyla/clodo-framework 3.0.12 → 3.0.14

package/CHANGELOG.md

@@ -1,3 +1,20 @@
+## [3.0.14](https://github.com/tamylaa/clodo-framework/compare/v3.0.13...v3.0.14) (2025-10-20)
+
+
+### Bug Fixes
+
+* add test environment compatibility fixes for ES modules ([71a033d](https://github.com/tamylaa/clodo-framework/commit/71a033d5d959480879c1a4771005553116e8671f))
+* ignore deployment artifacts in deployments/ directory ([768f453](https://github.com/tamylaa/clodo-framework/commit/768f453cbabb984509613a382d86875c1309bcd2))
+* resolve circular dependency in FeatureFlagManager ([d04956f](https://github.com/tamylaa/clodo-framework/commit/d04956f83527d3236fce2fe9750f71cdf0ba8d8e))
+* resolve ESLint errors and update test expectations ([b1188be](https://github.com/tamylaa/clodo-framework/commit/b1188be66d3723bfff62431f6e0eabec685b0111))
+* revert Jest config to working configuration that passes tests ([35a2846](https://github.com/tamylaa/clodo-framework/commit/35a28466c8a48c78011c128f89695399e8500341))
+* update Jest config to properly handle ES modules ([1a951c7](https://github.com/tamylaa/clodo-framework/commit/1a951c7ae147ddb8bef0ec1508c858ac044423b7))
+* update package-lock.json to sync with package.json dependencies ([a3ef884](https://github.com/tamylaa/clodo-framework/commit/a3ef8844cba2b5657a3493b8339c98049a57dd72))
+* update package.json semantic release config to support main branch ([a06b2e8](https://github.com/tamylaa/clodo-framework/commit/a06b2e899ceb7699b67292157991d64c88dedae3))
+* update semantic release config to support main branch ([4102e6c](https://github.com/tamylaa/clodo-framework/commit/4102e6c4cb4f52d065750239c2a0c5a89b733ac0))
+* update version to 3.0.13 to sync with release history ([f9bb4d4](https://github.com/tamylaa/clodo-framework/commit/f9bb4d463a3884b82e972962e5fcd21a272c3acb))
+* use os.tmpdir() for test paths to fix CI permission errors ([022c771](https://github.com/tamylaa/clodo-framework/commit/022c771994635002410c27d8eb7ec8f0614acf6f))
+
 ## [3.0.12](https://github.com/tamylaa/clodo-framework/compare/v3.0.11...v3.0.12) (2025-10-14)
 
 

package/bin/clodo-service.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 /**
  * Clodo Framework - Unified Three-Tier Service Management CLI
@@ -18,6 +18,8 @@ import chalk from 'chalk';
 import { join } from 'path';
 import { ServiceOrchestrator } from '../dist/service-management/ServiceOrchestrator.js';
 import { InputCollector } from '../dist/service-management/InputCollector.js';
+import { readFileSync, existsSync } from 'fs';
+import { resolve } from 'path';
 
 const program = new Command();
 
@@ -26,6 +28,117 @@ program
   .description('Unified conversational CLI for Clodo Framework service lifecycle management')
   .version('1.0.0');
 
+// Helper function to load JSON configuration file
+function loadJsonConfig(configPath) {
+  try {
+    const fullPath = resolve(configPath);
+    if (!existsSync(fullPath)) {
+      throw new Error(`Configuration file not found: ${fullPath}`);
+    }
+
+    const content = readFileSync(fullPath, 'utf8');
+    const config = JSON.parse(content);
+
+    // Validate required fields
+    const required = ['customer', 'environment', 'domainName', 'cloudflareToken'];
+    const missing = required.filter(field => !config[field]);
+
+    if (missing.length > 0) {
+      throw new Error(`Missing required configuration fields: ${missing.join(', ')}`);
+    }
+
+    console.log(chalk.green(`✅ Loaded configuration from: ${fullPath}`));
+    return config;
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new Error(`Invalid JSON in configuration file: ${error.message}`);
+    }
+    throw error;
+  }
+}
+
+// Simple progress indicator for deployment steps
+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
+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 !== '.') {
+    const { existsSync } = await import('fs');
+    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 { existsSync } = await import('fs');
+    const { join } = await import('path');
+    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;
+}
+
 // Main interactive command
 program
   .command('create')
@@ -414,6 +527,86 @@ program
     }
   });
 
+// Professional Edition: assess command (from clodo-orchestration)
+program
+  .command('assess [service-path]')
+  .description('Run intelligent capability assessment (requires @tamyla/clodo-orchestration)')
+  .option('--export <file>', 'Export assessment results to JSON file')
+  .option('--domain <domain>', 'Domain name for assessment')
+  .option('--service-type <type>', 'Service type for assessment')
+  .option('--token <token>', 'Cloudflare API token')
+  .action(async (servicePath, options) => {
+    try {
+      // Try to load professional orchestration package
+      let orchestrationModule;
+      try {
+        orchestrationModule = await import('@tamyla/clodo-orchestration');
+      } catch (err) {
+        console.error(chalk.red('❌ clodo-orchestration package not found'));
+        console.error(chalk.yellow('💡 Install with: npm install @tamyla/clodo-orchestration'));
+        process.exit(1);
+      }
+
+      const { 
+        CapabilityAssessmentEngine, 
+        ServiceAutoDiscovery,
+        runAssessmentWorkflow 
+      } = orchestrationModule;
+
+      const targetPath = servicePath || process.cwd();
+      console.log(chalk.cyan('\n🧠 Professional Capability Assessment'));
+      console.log(chalk.gray('─'.repeat(60)));
+      console.log(chalk.white(`Service Path: ${targetPath}`));
+      
+      if (options.domain) {
+        console.log(chalk.white(`Domain: ${options.domain}`));
+      }
+      if (options.serviceType) {
+        console.log(chalk.white(`Service Type: ${options.serviceType}`));
+      }
+      console.log(chalk.gray('─'.repeat(60)));
+
+      // Use the assessment workflow
+      const assessment = await runAssessmentWorkflow({
+        servicePath: targetPath,
+        domain: options.domain,
+        serviceType: options.serviceType,
+        token: options.token || process.env.CLOUDFLARE_API_TOKEN
+      });
+
+      // Display results
+      console.log(chalk.cyan('\n✅ Assessment Results'));
+      console.log(chalk.gray('─'.repeat(60)));
+      console.log(chalk.white(`Service Type: ${assessment.mergedInputs?.serviceType || assessment.serviceType || 'Not determined'}`));
+      console.log(chalk.white(`Confidence: ${assessment.confidence}%`));
+      
+      if (assessment.gapAnalysis?.missing) {
+        console.log(chalk.white(`Missing Capabilities: ${assessment.gapAnalysis.missing.length}`));
+        if (assessment.gapAnalysis.missing.length > 0) {
+          console.log(chalk.yellow('\n⚠️  Missing:'));
+          assessment.gapAnalysis.missing.forEach(gap => {
+            console.log(chalk.yellow(`   • ${gap.capability}: ${gap.reason || 'Not available'}`));
+          });
+        }
+      }
+
+      console.log(chalk.gray('─'.repeat(60)));
+
+      // Export results if requested
+      if (options.export) {
+        require('fs').writeFileSync(options.export, JSON.stringify(assessment, null, 2));
+        console.log(chalk.green(`\n📄 Results exported to: ${options.export}`));
+      }
+
+    } catch (error) {
+      console.error(chalk.red(`Assessment failed: ${error.message}`));
+      if (process.env.DEBUG) {
+        console.error(chalk.gray(error.stack));
+      }
+      process.exit(1);
+    }
+  });
+
 // Deploy command - using existing InputCollector + CustomerConfigLoader (reusable pattern)
 program
   .command('deploy')
@@ -422,6 +615,10 @@ program
   .option('-e, --env <environment>', 'Target environment (development, staging, production)')
   .option('-i, --interactive', 'Interactive mode (review confirmations)', true)
   .option('--non-interactive', 'Non-interactive mode (use stored config)')
+  .option('--config-file <file>', 'Load configuration from JSON file')
+  .option('--defaults', 'Use default values where possible (non-interactive)')
+  .option('--quiet', 'Quiet mode - minimal output for CI/CD')
+  .option('--json-output', 'Output results as JSON for scripting')
   .option('--dry-run', 'Simulate deployment without making changes')
   .option('--domain <domain>', 'Domain name (overrides stored config)')
   .option('--service-path <path>', 'Path to service directory', '.')
@@ -436,7 +633,9 @@ program
       console.log(chalk.cyan('\n🚀 Clodo Framework Deployment'));
       console.log(chalk.white('Using Three-Tier Input Architecture\n'));
       
-      const isInteractive = options.interactive && !options.nonInteractive;
+      const isInteractive = options.interactive && !options.nonInteractive && !options.configFile && !options.defaults;
+      const isQuiet = options.quiet;
+      const jsonOutput = options.jsonOutput;
       const configManager = new UnifiedConfigManager({
         configDir: join(process.cwd(), 'config', 'customers')
       });
@@ -446,216 +645,285 @@ program
       let coreInputs = {};
       let source = 'interactive';
       
-      try {
-        // Try UnifiedConfigManager to load existing config
-        let storedConfig = null;
-        
-        if (options.customer && options.env) {
-          // Check UnifiedConfigManager for existing config
-          if (configManager.configExists(options.customer, options.env)) {
-            console.log(chalk.green(`✅ Found existing configuration for ${options.customer}/${options.env}\n`));
-            configManager.displayCustomerConfig(options.customer, options.env);
-            
-            if (!isInteractive) {
+      // Interactive mode: run input collector
+      if (isInteractive) {
+          await inputCollector.collect();
+        } else {
+          // Non-interactive mode: load from config file or stored config
+          
+          // Load from JSON config file if specified
+          if (options.configFile) {
+            coreInputs = loadJsonConfig(options.configFile);
+            source = 'config-file';
+          } else if (options.customer && options.env) {
+            // Check UnifiedConfigManager for existing config
+            if (configManager.configExists(options.customer, options.env)) {
+              console.log(chalk.green(`✅ Found existing configuration for ${options.customer}/${options.env}\n`));
+              configManager.displayCustomerConfig(options.customer, options.env);
+              
               // Non-interactive: auto-load the config
-              storedConfig = configManager.loadCustomerConfig(options.customer, options.env);
+              const storedConfig = configManager.loadCustomerConfig(options.customer, options.env);
               if (storedConfig) {
                 coreInputs = storedConfig;
                 source = 'stored-config';
               }
             } else {
-              // Interactive: ask if they want to use it
-              const useExisting = await inputCollector.question('\n   💡 Use existing configuration? (Y/n): ');
-              
-              if (useExisting.toLowerCase() !== 'n') {
-                storedConfig = configManager.loadCustomerConfig(options.customer, options.env);
-                if (storedConfig) {
-                  coreInputs = storedConfig;
-                  source = 'stored-config';
+              console.log(chalk.yellow(`⚠️  No configuration found for ${options.customer}/${options.env}`));
+              console.log(chalk.white('Collecting inputs interactively...\n'));
+            }
+          } else {
+            console.log(chalk.yellow('⚠️  Customer and environment not specified'));
+            console.log(chalk.white('Use --customer and --env options, or run in interactive mode'));
+            process.exit(1);
+          }
+          
+          // Collect inputs if we don't have them from stored config
+          if (!coreInputs.cloudflareAccountId) {
+            console.log(chalk.cyan('📊 Tier 1: Core Input Collection\n'));
+            
+            // Collect basic info with smart customer selection
+            let customer = options.customer;
+            if (!customer) {
+              const customers = configManager.listCustomers();
+              if (customers.length > 0) {
+                const selection = await inputCollector.question('Select customer (enter number or name): ');
+                
+                // Try to parse as number first
+                const num = parseInt(selection);
+                if (!isNaN(num) && num >= 1 && num <= customers.length) {
+                  customer = customers[num - 1];
+                  console.log(chalk.green(`✓ Selected: ${customer}\n`));
+                } else if (customers.includes(selection)) {
+                  customer = selection;
+                  console.log(chalk.green(`✓ Selected: ${customer}\n`));
+                } else {
+                  // New customer name
+                  customer = selection;
+                  console.log(chalk.yellow(`⚠️  Creating new customer: ${customer}\n`));
                 }
               } else {
-                console.log(chalk.white('\n   📝 Collecting new configuration...\n'));
+                customer = await inputCollector.question('Customer name: ');
               }
             }
-          } else {
-            console.log(chalk.yellow(`⚠️  No configuration found for ${options.customer}/${options.env}`));
-            console.log(chalk.white('Collecting inputs interactively...\n'));
+            const environment = options.env || await inputCollector.collectEnvironment();
+            const serviceName = await inputCollector.collectServiceName();
+            const serviceType = await inputCollector.collectServiceType();
+            
+            // Collect Cloudflare token
+            const cloudflareToken = process.env.CLOUDFLARE_API_TOKEN || await inputCollector.collectCloudflareToken();
+            
+            // Use CloudflareAPI for automatic domain discovery
+            console.log(chalk.cyan('⏳ Fetching Cloudflare configuration...'));
+            const cloudflareConfig = await inputCollector.collectCloudflareConfigWithDiscovery(
+              cloudflareToken,
+              options.domain
+            );
+            
+            // Combine all inputs
+            coreInputs = {
+              customer,
+              environment,
+              serviceName,
+              serviceType,
+              domainName: cloudflareConfig.domainName,
+              cloudflareToken,
+              cloudflareAccountId: cloudflareConfig.accountId,
+              cloudflareZoneId: cloudflareConfig.zoneId
+            };
+            
+            source = 'interactive';
+          }
+          
+          // Allow domain override
+          if (options.domain) {
+            coreInputs.domainName = options.domain;
+          }
+          
+          // Early validation before proceeding
+          const isValid = await validateDeploymentPrerequisites(coreInputs, options);
+          if (!isValid) {
+            console.log(chalk.red('\n❌ Deployment cancelled due to validation errors.'));
+            console.log(chalk.cyan('💡 Fix the issues above and try again.'));
+            process.exit(1);
+          }
+          
+          // Tier 2: Generate smart confirmations using existing ConfirmationHandler
+          // Note: ConfirmationEngine prints its own header
+          const confirmations = await confirmationHandler.generateAndConfirm(coreInputs);
+          
+          // Show deployment summary
+          console.log(chalk.cyan('\n📊 Deployment Summary'));
+          console.log(chalk.gray('─'.repeat(60)));
+          
+          console.log(chalk.white(`Source:        ${source}`));
+          console.log(chalk.white(`Customer:      ${coreInputs.customer}`));
+          console.log(chalk.white(`Environment:   ${coreInputs.environment}`));
+          console.log(chalk.white(`Domain:        ${coreInputs.domainName}`));
+          console.log(chalk.white(`Account ID:    ${coreInputs.cloudflareAccountId ? coreInputs.cloudflareAccountId.substring(0, 8) + '...' : 'N/A'}`));
+          console.log(chalk.white(`Zone ID:       ${coreInputs.cloudflareZoneId ? coreInputs.cloudflareZoneId.substring(0, 8) + '...' : 'N/A'}`));
+          
+          if (confirmations.workerName) {
+            console.log(chalk.white(`Worker:        ${confirmations.workerName}`));
+          }
+          if (confirmations.databaseName) {
+            console.log(chalk.white(`Database:      ${confirmations.databaseName}`));
           }
           
-          // Use stored config if we found it and haven't collected inputs yet
-          if (storedConfig && !coreInputs.cloudflareAccountId) {
-            coreInputs = storedConfig;
-            source = 'stored-config';
-            console.log(chalk.green('\n✅ Using stored configuration\n'));
+          console.log(chalk.gray('─'.repeat(60)));
+          
+          if (options.dryRun) {
+            console.log(chalk.yellow('\n🔍 DRY RUN MODE - No changes will be made\n'));
           }
-        } else if (!options.customer) {
-          // Show available customers to help user
-          const customers = configManager.listCustomers();
-          if (customers.length > 0) {
-            console.log(chalk.cyan('💡 Configured customers:'));
-            customers.forEach((customer, index) => {
-              console.log(chalk.white(`   ${index + 1}. ${customer}`));
+          
+          // Tier 3: Execute deployment
+          console.log(chalk.cyan('\n⚙️  Tier 3: Automated Deployment\n'));
+          
+          // OPTIONAL: Try to load professional orchestration package if available
+          let professionalOrchestration = null;
+          try {
+            const { runAssessmentWorkflow } = await import('@tamyla/clodo-orchestration');
+            professionalOrchestration = { runAssessmentWorkflow };
+            console.log(chalk.cyan('📊 Professional Edition (clodo-orchestration) detected'));
+          } catch (err) {
+            // clodo-orchestration not installed, continue with standard assessment
+            if (process.env.DEBUG) {
+              console.log(chalk.gray(`   ℹ️  clodo-orchestration not available: ${err.message}`));
+            }
+          }
+          
+          // INTEGRATION: Add intelligent service discovery and assessment
+          console.log(chalk.cyan('🧠 Performing Intelligent Service Assessment...'));
+          const { CapabilityAssessmentEngine } = await import('../dist/service-management/CapabilityAssessmentEngine.js');
+          const assessor = new CapabilityAssessmentEngine(options.servicePath || process.cwd());
+          
+          try {
+            const assessment = await assessor.assessCapabilities({
+              serviceName: coreInputs.serviceName,
+              serviceType: coreInputs.serviceType,
+              environment: coreInputs.environment,
+              domainName: coreInputs.domainName
             });
+            
+            // Display assessment results
+            console.log(chalk.green('✅ Assessment Complete'));
+            console.log(chalk.white(`   Service Type: ${assessment.mergedInputs.serviceType || 'Not determined'}`));
+            console.log(chalk.white(`   Confidence: ${assessment.confidence}%`));
+            console.log(chalk.white(`   Missing Capabilities: ${assessment.gapAnalysis.missing.length}`));
+            
+            // Show any blocking issues
+            const blockingIssues = assessment.gapAnalysis.missing.filter(gap => gap.priority === 'blocked');
+            if (blockingIssues.length > 0) {
+              console.log(chalk.yellow('\n⚠️  Permission-limited capabilities detected:'));
+              blockingIssues.forEach(issue => {
+                console.log(chalk.yellow(`   - ${issue.capability}: ${issue.reason}`));
+              });
+            }
+            
+            console.log('');
+            
+          } catch (assessmentError) {
+            console.log(chalk.yellow('⚠️  Assessment failed, proceeding with deployment:'), assessmentError.message);
             console.log('');
           }
-        }
-        
-        // Collect inputs if we don't have them from stored config
-        if (!coreInputs.cloudflareAccountId) {
-          console.log(chalk.cyan('📊 Tier 1: Core Input Collection\n'));
           
-          // Collect basic info with smart customer selection
-          let customer = options.customer;
-          if (!customer) {
-            const customers = configManager.listCustomers();
-            if (customers.length > 0) {
-              const selection = await inputCollector.question('Select customer (enter number or name): ');
-              
-              // Try to parse as number first
-              const num = parseInt(selection);
-              if (!isNaN(num) && num >= 1 && num <= customers.length) {
-                customer = customers[num - 1];
-                console.log(chalk.green(`✓ Selected: ${customer}\n`));
-              } else if (customers.includes(selection)) {
-                customer = selection;
-                console.log(chalk.green(`✓ Selected: ${customer}\n`));
-              } else {
-                // New customer name
-                customer = selection;
-                console.log(chalk.yellow(`⚠️  Creating new customer: ${customer}\n`));
-              }
-            } else {
-              customer = await inputCollector.question('Customer name: ');
+          const orchestrator = new MultiDomainOrchestrator({
+            domains: [coreInputs.domainName],
+            environment: coreInputs.environment,
+            dryRun: options.dryRun,
+            servicePath: options.servicePath,
+            cloudflareToken: coreInputs.cloudflareToken,
+            cloudflareAccountId: coreInputs.cloudflareAccountId
+          });
+          
+          // Show progress for initialization
+          await showProgress('Initializing deployment orchestrator', 1500);
+          await orchestrator.initialize();
+          
+          console.log(chalk.cyan('🚀 Starting deployment...\n'));
+          
+          // Show progress during deployment
+          const deployPromise = orchestrator.deploySingleDomain(coreInputs.domainName, {
+            ...coreInputs,
+            ...confirmations,
+            servicePath: options.servicePath
+          });
+          
+          // Show deployment progress
+          const progressMessages = [
+            'Preparing deployment configuration',
+            'Setting up Cloudflare resources', 
+            'Deploying worker script',
+            'Configuring database connections',
+            'Setting up domain routing',
+            'Running final health checks'
+          ];
+          
+          let progressIndex = 0;
+          const progressInterval = setInterval(() => {
+            if (progressIndex < progressMessages.length) {
+              console.log(chalk.gray(`   ${progressMessages[progressIndex]}`));
+              progressIndex++;
             }
+          }, 2000);
+          
+          const result = await deployPromise;
+          clearInterval(progressInterval);
+          
+          // Fill in remaining progress messages quickly
+          while (progressIndex < progressMessages.length) {
+            console.log(chalk.gray(`   ${progressMessages[progressIndex]}`));
+            progressIndex++;
           }
-          const environment = options.env || await inputCollector.collectEnvironment();
-          const serviceName = await inputCollector.collectServiceName();
-          const serviceType = await inputCollector.collectServiceType();
           
-          // Collect Cloudflare token
-          const cloudflareToken = process.env.CLOUDFLARE_API_TOKEN || await inputCollector.collectCloudflareToken();
+          // Display results with cleaner formatting
+          console.log(chalk.green('\n✅ Deployment Completed Successfully!'));
+          console.log(chalk.gray('─'.repeat(60)));
           
-          // Use CloudflareAPI for automatic domain discovery
-          console.log(chalk.cyan('⏳ Fetching Cloudflare configuration...'));
-          const cloudflareConfig = await inputCollector.collectCloudflareConfigWithDiscovery(
-            cloudflareToken,
-            options.domain
-          );
+          // Show key information prominently
+          if (result.url || confirmations.deploymentUrl) {
+            console.log(chalk.white(`🌐 Service URL:    ${chalk.bold(result.url || confirmations.deploymentUrl)}`));
+          }
           
-          // Combine all inputs
-          coreInputs = {
-            customer,
-            environment,
-            serviceName,
-            serviceType,
-            domainName: cloudflareConfig.domainName,
-            cloudflareToken,
-            cloudflareAccountId: cloudflareConfig.accountId,
-            cloudflareZoneId: cloudflareConfig.zoneId
-          };
+          console.log(chalk.white(`👤 Customer:      ${coreInputs.customer}`));
+          console.log(chalk.white(`🏭 Environment:   ${coreInputs.environment}`));
+          console.log(chalk.white(`🔧 Worker:        ${confirmations.workerName || 'N/A'}`));
           
-          source = 'interactive';
-        }
-        
-        // Allow domain override
-        if (options.domain) {
-          coreInputs.domainName = options.domain;
-        }
-        
-        // Tier 2: Generate smart confirmations using existing ConfirmationHandler
-        // Note: ConfirmationEngine prints its own header
-        const confirmations = await confirmationHandler.generateAndConfirm(coreInputs);
-        
-        // Show deployment summary
-        console.log(chalk.cyan('\n📊 Deployment Summary'));
-        console.log(chalk.gray('─'.repeat(60)));
-        
-        console.log(chalk.white(`Source:        ${source}`));
-        console.log(chalk.white(`Customer:      ${coreInputs.customer}`));
-        console.log(chalk.white(`Environment:   ${coreInputs.environment}`));
-        console.log(chalk.white(`Domain:        ${coreInputs.domainName}`));
-        console.log(chalk.white(`Account ID:    ${coreInputs.cloudflareAccountId?.substring(0, 8)}...`));
-        console.log(chalk.white(`Zone ID:       ${coreInputs.cloudflareZoneId?.substring(0, 8)}...`));
-        
-        if (confirmations.workerName) {
-          console.log(chalk.white(`Worker:        ${confirmations.workerName}`));
-        }
-        if (confirmations.databaseName) {
-          console.log(chalk.white(`Database:      ${confirmations.databaseName}`));
-        }
-        
-        console.log(chalk.gray('─'.repeat(60)));
-        
-        if (options.dryRun) {
-          console.log(chalk.yellow('\n🔍 DRY RUN MODE - No changes will be made\n'));
-        }
-        
-        // Tier 3: Execute deployment
-        console.log(chalk.cyan('\n⚙️  Tier 3: Automated Deployment\n'));
-        
-        const orchestrator = new MultiDomainOrchestrator({
-          domains: [coreInputs.domainName],
-          environment: coreInputs.environment,
-          dryRun: options.dryRun,
-          servicePath: options.servicePath,
-          cloudflareToken: coreInputs.cloudflareToken,
-          cloudflareAccountId: coreInputs.cloudflareAccountId
-        });
-        
-        await orchestrator.initialize();
-        
-        console.log(chalk.cyan('🚀 Starting deployment...\n'));
-        
-        const result = await orchestrator.deploySingleDomain(coreInputs.domainName, {
-          ...coreInputs,
-          ...confirmations,
-          servicePath: options.servicePath
-        });
-        
-        // Display results
-        console.log(chalk.green('\n✅ Deployment Completed Successfully!'));
-        console.log(chalk.gray('─'.repeat(60)));
-        console.log(chalk.white(`   Worker:   ${confirmations.workerName || 'N/A'}`));
-        console.log(chalk.white(`   URL:      ${result.url || confirmations.deploymentUrl || 'N/A'}`));
-        console.log(chalk.white(`   Status:   ${result.status || 'deployed'}`));
-        
-        if (result.health) {
-          console.log(chalk.white(`   Health:   ${result.health}`));
-        }
-        
-        console.log(chalk.gray('─'.repeat(60)));
-        
-        // Save deployment configuration for future reuse
-        try {
-          console.log(chalk.cyan('\n💾 Saving deployment configuration...'));
+          if (result.health) {
+            const healthStatus = result.health.toLowerCase().includes('ok') || result.health.toLowerCase().includes('healthy') 
+              ? chalk.green('✅ Healthy') 
+              : chalk.yellow('⚠️ Check required');
+            console.log(chalk.white(`💚 Health:        ${healthStatus}`));
+          }
           
-          const configFile = await configManager.saveCustomerConfig(
-            coreInputs.customer,
-            coreInputs.environment,
-            {
-              coreInputs,
-              confirmations,
-              result
-            }
-          );
+          console.log(chalk.gray('─'.repeat(60)));
+          
+          // Save deployment configuration for future reuse
+          try {
+            console.log(chalk.cyan('\n💾 Saving deployment configuration...'));
+            
+            const configFile = await configManager.saveCustomerConfig(
+              coreInputs.customer,
+              coreInputs.environment,
+              {
+                coreInputs,
+                confirmations,
+                result
+              }
+            );
+            
+            console.log(chalk.green('   ✅ Configuration saved for future deployments'));
+            console.log(chalk.gray(`   📄 File: ${configFile}`));
+          } catch (saveError) {
+            console.log(chalk.yellow(`   ⚠️  Could not save configuration: ${saveError.message}`));
+            console.log(chalk.gray('   Deployment succeeded, but you may need to re-enter values next time.'));
+          }
           
-          console.log(chalk.green('   ✅ Configuration saved successfully!'));
-          console.log(chalk.gray(`   📄 File: ${configFile}`));
-          console.log(chalk.white('   💡 Next deployment will automatically load these settings'));
-        } catch (saveError) {
-          console.log(chalk.yellow(`   ⚠️  Could not save configuration: ${saveError.message}`));
-          console.log(chalk.gray('   Deployment succeeded, but you may need to re-enter values next time.'));
+          console.log(chalk.cyan('\n📋 Next Steps:'));
+          console.log(chalk.white(`   • Test deployment: curl ${result.url || confirmations.deploymentUrl}/health`));
+          console.log(chalk.white(`   • Monitor logs: wrangler tail ${confirmations.workerName}`));
+          console.log(chalk.white(`   • View dashboard: https://dash.cloudflare.com`));
         }
         
-        console.log(chalk.cyan('\n📋 Next Steps:'));
-        console.log(chalk.white(`   • Test deployment: curl ${result.url || confirmations.deploymentUrl}/health`));
-        console.log(chalk.white(`   • Monitor logs: wrangler tail ${confirmations.workerName}`));
-        console.log(chalk.white(`   • View dashboard: https://dash.cloudflare.com`));
-        
-      } finally {
-        inputCollector.close();
-      }
-      
     } catch (error) {
       console.error(chalk.red(`\n❌ Deployment failed: ${error.message}`));
       
@@ -687,4 +955,30 @@ program
     }
   });
 
+// Utility function to redact sensitive information from logs
+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;
+}
+
 program.parse();

package/bin/shared/security/secret-generator.js

@@ -17,8 +17,13 @@ import { execSync } from 'child_process';
 import { fileURLToPath } from 'url';
 
 const __dirname = (() => {
-  const filename = fileURLToPath(import.meta.url);
-  return dirname(filename);
+  try {
+    const filename = fileURLToPath(import.meta.url);
+    return dirname(filename);
+  } catch (error) {
+    // Fallback for test environments - use current working directory
+    return process.cwd();
+  }
 })();
 
 const SECRET_CONFIGS = {

package/dist/config/customers.js

@@ -3,10 +3,16 @@ import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, statSy
 import { resolve, join } from 'path';
 import toml from '@iarna/toml';
 import { createDomainConfigSchema, validateDomainConfig, createDomainRegistry } from './domains.js';
-import { createLogger } from '../utils/index.js';
 import { getDirname } from '../utils/esm-helper.js';
 const __dirname = getDirname(import.meta.url, 'src/config');
-const logger = createLogger('CustomerConfig');
+
+// Simple inline logger to avoid circular dependency with index.js
+const logger = {
+  info: (message, ...args) => console.log(`[CustomerConfig] ${message}`, ...args),
+  error: (message, ...args) => console.error(`[CustomerConfig] ${message}`, ...args),
+  warn: (message, ...args) => console.warn(`[CustomerConfig] ${message}`, ...args),
+  debug: (message, ...args) => console.debug(`[CustomerConfig] ${message}`, ...args)
+};
 
 /**
  * Customer Configuration Manager

package/dist/config/domains.js

@@ -1,5 +1,11 @@
-import { deepMerge, validateRequired, createLogger } from '../utils/index.js';
-const logger = createLogger('DomainConfig');
+// Simple inline logger to avoid circular dependency with index.js
+import { validateRequired, deepMerge } from '../utils/index.js';
+const logger = {
+  info: (message, ...args) => console.log(`[DomainConfig] ${message}`, ...args),
+  error: (message, ...args) => console.error(`[DomainConfig] ${message}`, ...args),
+  warn: (message, ...args) => console.warn(`[DomainConfig] ${message}`, ...args),
+  debug: (message, ...args) => console.debug(`[DomainConfig] ${message}`, ...args)
+};
 
 /**
  * Creates a base domain configuration schema

package/dist/config/features.js

@@ -1,5 +1,10 @@
-import { createLogger } from '../utils/index.js';
-const logger = createLogger('FeatureFlags');
+// Simple inline logger to avoid circular dependency with index.js
+const logger = {
+  info: (message, ...args) => console.log(`[FeatureFlagManager] ${message}`, ...args),
+  error: (message, ...args) => console.error(`[FeatureFlagManager] ${message}`, ...args),
+  warn: (message, ...args) => console.warn(`[FeatureFlagManager] ${message}`, ...args),
+  debug: (message, ...args) => console.debug(`[FeatureFlagManager] ${message}`, ...args)
+};
 
 /**
  * Feature Flag Manager Class

package/dist/index.js

@@ -24,6 +24,14 @@ export { WranglerDeployer } from './deployment/wrangler-deployer.js';
 // Security components
 export * from './security/index.js';
 
+// Service management components
+export { ServiceCreator, createService } from './service-management/ServiceCreator.js';
+export { ServiceOrchestrator } from './service-management/ServiceOrchestrator.js';
+export { InputHandler } from './service-management/handlers/InputHandler.js';
+export { ConfirmationHandler } from './service-management/handlers/ConfirmationHandler.js';
+export { GenerationHandler } from './service-management/handlers/GenerationHandler.js';
+export { ValidationHandler } from './service-management/handlers/ValidationHandler.js';
+
 // Framework version info
 export const FRAMEWORK_VERSION = '1.0.0';
 export const FRAMEWORK_NAME = 'Clodo Framework';

package/dist/orchestration/multi-domain-orchestrator.js

@@ -597,7 +597,7 @@ export class MultiDomainOrchestrator {
   }
 
   /**
-   * Validate domain deployment with real HTTP health check
+   * Validate domain deployment with real HTTP health check (with retries)
    */
   async validateDomainDeployment(domain) {
     console.log(`   ✅ Validating deployment for ${domain}`);
@@ -614,54 +614,75 @@ export class MultiDomainOrchestrator {
       return true;
     }
     console.log(`   🔍 Running health check: ${deploymentUrl}/health`);
-    try {
-      const startTime = Date.now();
-
-      // Perform actual HTTP health check
-      const response = await fetch(`${deploymentUrl}/health`, {
-        method: 'GET',
-        headers: {
-          'User-Agent': 'Clodo-Orchestrator/2.0'
-        },
-        signal: AbortSignal.timeout(10000) // 10 second timeout
-      });
-      const responseTime = Date.now() - startTime;
-      const status = response.status;
-      if (status === 200) {
-        console.log(`   ✅ Health check passed (${status}) - Response time: ${responseTime}ms`);
-
-        // Log successful health check
-        this.stateManager.logAuditEvent('HEALTH_CHECK_PASSED', domain, {
-          url: deploymentUrl,
-          status,
-          responseTime,
-          environment: this.environment
-        });
-        return true;
-      } else {
-        console.log(`   ⚠️  Health check returned ${status} - deployment may have issues`);
-        this.stateManager.logAuditEvent('HEALTH_CHECK_WARNING', domain, {
-          url: deploymentUrl,
-          status,
-          responseTime,
-          environment: this.environment
+
+    // Retry logic for health checks
+    const maxRetries = 3;
+    const retryDelay = 5000; // 5 seconds between retries
+
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        const startTime = Date.now();
+        console.log(`   Attempt ${attempt}/${maxRetries}...`);
+
+        // Perform actual HTTP health check
+        const response = await fetch(`${deploymentUrl}/health`, {
+          method: 'GET',
+          headers: {
+            'User-Agent': 'Clodo-Orchestrator/2.0'
+          },
+          signal: AbortSignal.timeout(15000) // 15 second timeout
         });
+        const responseTime = Date.now() - startTime;
+        const status = response.status;
+        if (status === 200) {
+          console.log(`   ✅ Health check passed (${status}) - Response time: ${responseTime}ms`);
+
+          // Log successful health check
+          this.stateManager.logAuditEvent('HEALTH_CHECK_PASSED', domain, {
+            url: deploymentUrl,
+            status,
+            responseTime,
+            attempt,
+            environment: this.environment
+          });
+          return true;
+        } else {
+          const errorMsg = `Health check returned ${status} - deployment may have issues`;
+          console.log(`   ⚠️  ${errorMsg}`);
+          this.stateManager.logAuditEvent('HEALTH_CHECK_WARNING', domain, {
+            url: deploymentUrl,
+            status,
+            responseTime,
+            attempt,
+            environment: this.environment
+          });
 
-        // Don't fail deployment for non-200 status, just warn
-        return true;
-      }
-    } catch (error) {
-      console.log(`   ⚠️  Health check failed: ${error.message}`);
-      console.log(`   💡 This may be expected if the worker isn't fully propagated yet`);
-      this.stateManager.logAuditEvent('HEALTH_CHECK_FAILED', domain, {
-        url: deploymentUrl,
-        error: error.message,
-        environment: this.environment
-      });
+          // Don't fail deployment for non-200 status, just warn
+          return true;
+        }
+      } catch (error) {
+        const isLastAttempt = attempt === maxRetries;
+        const errorMsg = `Health check failed: ${error.message}`;
+        if (isLastAttempt) {
+          console.log(`   ❌ ${errorMsg} (final attempt)`);
+          console.log(`   💡 The service may still be deploying. Check manually: curl ${deploymentUrl}/health`);
+          this.stateManager.logAuditEvent('HEALTH_CHECK_FAILED', domain, {
+            url: deploymentUrl,
+            error: error.message,
+            attempts: maxRetries,
+            environment: this.environment
+          });
 
-      // Don't fail deployment for health check failure - it might just need time
-      return true;
+          // Don't fail deployment for health check failure - it might just need time
+          return true;
+        } else {
+          console.log(`   ⚠️  ${errorMsg} (attempt ${attempt}/${maxRetries})`);
+          console.log(`   ⏳ Retrying in ${retryDelay / 1000} seconds...`);
+          await new Promise(resolve => setTimeout(resolve, retryDelay));
+        }
+      }
     }
+    return true;
   }
 
   /**

package/dist/service-management/ConfirmationEngine.js

@@ -81,10 +81,10 @@ export class ConfirmationEngine {
       version: '1.0.0',
       // 4. Author - Default framework author
       author: 'Clodo Framework',
-      // 5-7. URLs - Derived from domain
-      productionUrl: `https://api.${domainName}`,
-      stagingUrl: `https://staging-api.${domainName}`,
-      developmentUrl: `https://dev-api.${domainName}`,
+      // 5-7. URLs - Derived from domain and service name
+      productionUrl: `https://${serviceName}.${domainName}`,
+      stagingUrl: `https://${serviceName}-staging.${domainName}`,
+      developmentUrl: `https://${serviceName}-dev.${domainName}`,
       // 8. Features - Based on service type
       features: this.generateFeaturesForType(serviceType),
       // 9. Database Name - Cloudflare D1 naming

package/dist/service-management/GenerationEngine.js

@@ -36,8 +36,13 @@ import { fileURLToPath } from 'url';
 import { dirname, join, relative } from 'path';
 import { existsSync, mkdirSync, writeFileSync } from 'fs';
 const __dirname = (() => {
-  const filename = fileURLToPath(import.meta.url);
-  return dirname(filename);
+  try {
+    const filename = fileURLToPath(import.meta.url);
+    return dirname(filename);
+  } catch (error) {
+    // Fallback for test environments - use current working directory
+    return process.cwd();
+  }
 })();
 export class GenerationEngine {
   constructor(options = {}) {
@@ -148,12 +153,14 @@ export class GenerationEngine {
     const wranglerConfig = serviceInitializer.generateWranglerConfig(coreInputs.serviceName, {
       type: coreInputs.serviceType,
       env: coreInputs.environment
-    }, [{
-      domain: coreInputs.domainName,
-      accountId: coreInputs.cloudflareAccountId,
-      zoneId: coreInputs.cloudflareZoneId,
-      name: `${coreInputs.serviceName}-${coreInputs.environment}`
-    }]);
+    }, {
+      domains: [{
+        domain: coreInputs.domainName,
+        accountId: coreInputs.cloudflareAccountId,
+        zoneId: coreInputs.cloudflareZoneId,
+        name: `${coreInputs.serviceName}-${coreInputs.environment}`
+      }]
+    });
 
     // Write wrangler.toml
     const wranglerPath = join(servicePath, 'wrangler.toml');
@@ -177,12 +184,14 @@ export class GenerationEngine {
     const domainsContent = serviceInitializer.generateDomainsConfig(coreInputs.serviceName, {
       type: coreInputs.serviceType,
       env: coreInputs.environment
-    }, [{
-      domain: coreInputs.domainName,
-      accountId: coreInputs.cloudflareAccountId,
-      zoneId: coreInputs.cloudflareZoneId,
-      name: `${coreInputs.serviceName}-${coreInputs.environment}`
-    }]);
+    }, {
+      domains: [{
+        domain: coreInputs.domainName,
+        accountId: coreInputs.cloudflareAccountId,
+        zoneId: coreInputs.cloudflareZoneId,
+        name: `${coreInputs.serviceName}-${coreInputs.environment}`
+      }]
+    });
     const domainsPath = join(servicePath, 'src', 'config', 'domains.js');
     writeFileSync(domainsPath, domainsContent, 'utf8');
     files.push(domainsPath);

package/dist/service-management/InputCollector.js

@@ -15,6 +15,9 @@ import { createInterface } from 'readline';
 import chalk from 'chalk';
 import { validateServiceName, validateDomainName } from '../utils/validation.js';
 import { uiStructuresLoader } from '../utils/ui-structures-loader.js';
+
+// Assessment capabilities moved to @tamyla/clodo-orchestration (professional edition)
+
 export class InputCollector {
   constructor(options = {}) {
     this.interactive = options.interactive !== false;
@@ -80,6 +83,8 @@ export class InputCollector {
           source: 'user-provided',
           required: true
         };
+
+        // Assessment moved to professional edition (@tamyla/clodo-orchestration)
       }
     }
 
@@ -158,9 +163,9 @@ export class InputCollector {
       case 'production-url':
         return domainName ? `https://api.${domainName}` : '';
       case 'staging-url':
-        return domainName ? `https://staging-api.${domainName}` : '';
+        return domainName && serviceName ? `https://${serviceName}-staging.${domainName}` : '';
       case 'development-url':
-        return domainName ? `https://dev-api.${domainName}` : '';
+        return domainName && serviceName ? `https://${serviceName}-dev.${domainName}` : '';
       case 'service-directory':
         return serviceName ? `./services/${serviceName}` : '';
       case 'database-name':

package/dist/service-management/ServiceCreator.js

@@ -6,13 +6,18 @@
 import { readFileSync, writeFileSync, mkdirSync, existsSync, cpSync, readdirSync, statSync } from 'fs';
 import { join, dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const TEMPLATES_DIR = join(__dirname, '..', '..', 'templates');
 const SERVICE_TYPES = ['data-service', 'auth-service', 'content-service', 'api-gateway', 'generic'];
 export class ServiceCreator {
   constructor(options = {}) {
-    this.templatesDir = options.templatesDir || TEMPLATES_DIR;
+    const templatesDir = (() => {
+      try {
+        return join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'templates');
+      } catch (error) {
+        // Fallback for test environments - use current working directory
+        return join(process.cwd(), 'templates');
+      }
+    })();
+    this.templatesDir = options.templatesDir || templatesDir;
     this.serviceTypes = options.serviceTypes || SERVICE_TYPES;
   }
 

package/dist/service-management/ServiceInitializer.js

@@ -6,11 +6,20 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync, cpSync, readdirSync } from 'fs';
 import { join, dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
-const FRAMEWORK_ROOT = (() => {
-  const filename = fileURLToPath(import.meta.url);
-  const dirname_ = dirname(filename);
-  return resolve(dirname_, '..', '..');
-})();
+
+// Get framework root - handle both ES module and CommonJS environments
+const getFrameworkRoot = () => {
+  try {
+    // Try ES module approach
+    const filename = fileURLToPath(import.meta.url);
+    const dirname_ = dirname(filename);
+    return resolve(dirname_, '..', '..');
+  } catch (error) {
+    // Fallback for test environments - use current working directory
+    return process.cwd();
+  }
+};
+const FRAMEWORK_ROOT = getFrameworkRoot();
 const TEMPLATES_DIR = join(FRAMEWORK_ROOT, 'templates');
 const SERVICE_TYPES = ['generic', 'data-service', 'auth-service', 'content-service', 'api-gateway'];
 export class ServiceInitializer {

package/dist/service-management/index.js

@@ -4,4 +4,11 @@
  */
 
 export { ServiceCreator, createService } from './ServiceCreator.js';
-export { ServiceInitializer, initializeService } from './ServiceInitializer.js';
+export { ServiceInitializer, initializeService } from './ServiceInitializer.js';
+
+// Assessment capabilities moved to @tamyla/clodo-orchestration
+// - AssessmentCache
+// - CapabilityAssessmentEngine
+// - ServiceAutoDiscovery
+// - Data-bridge components
+// These are only available in the professional edition (clodo-orchestration)

package/dist/shared/security/secret-generator.js

@@ -16,8 +16,13 @@ import { join, dirname } from 'path';
 import { execSync } from 'child_process';
 import { fileURLToPath } from 'url';
 const __dirname = (() => {
-  const filename = fileURLToPath(import.meta.url);
-  return dirname(filename);
+  try {
+    const filename = fileURLToPath(import.meta.url);
+    return dirname(filename);
+  } catch (error) {
+    // Fallback for test environments - use current working directory
+    return process.cwd();
+  }
 })();
 const SECRET_CONFIGS = {
   'AUTH_JWT_SECRET': {

package/dist/utils/config/unified-config-manager.js

@@ -15,9 +15,13 @@
 import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, statSync } from 'fs';
 import { resolve, join } from 'path';
 import { getDirname } from '../esm-helper.js';
-import { createLogger } from '../index.js';
 const __dirname = getDirname(import.meta.url, 'src/utils/config');
-const logger = createLogger('UnifiedConfigManager');
+
+// Simple inline logger to avoid circular dependency with index.js
+const logger = {
+  info: (message, ...args) => console.log(`[UnifiedConfigManager] ${message}`, ...args),
+  error: (message, ...args) => console.error(`[UnifiedConfigManager] ${message}`, ...args)
+};
 
 /**
  * UnifiedConfigManager

package/dist/worker/integration.js

@@ -1,7 +1,13 @@
 import { featureManager, COMMON_FEATURES } from '../config/features.js';
 import { getDomainFromEnv, createEnvironmentConfig } from '../config/domains.js';
-import { createLogger } from '../utils/index.js';
-const logger = createLogger('WorkerIntegration');
+
+// Simple inline logger to avoid circular dependency with index.js
+const logger = {
+  info: (message, ...args) => console.log(`[WorkerIntegration] ${message}`, ...args),
+  error: (message, ...args) => console.error(`[WorkerIntegration] ${message}`, ...args),
+  warn: (message, ...args) => console.warn(`[WorkerIntegration] ${message}`, ...args),
+  debug: (message, ...args) => console.debug(`[WorkerIntegration] ${message}`, ...args)
+};
 
 /**
  * Initializes a service with domain and feature context

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tamyla/clodo-framework",
-  "version": "3.0.12",
+  "version": "3.0.14",
   "description": "Reusable framework for Clodo-style software architecture on Cloudflare Workers + D1",
   "type": "module",
   "sideEffects": [
@@ -74,7 +74,7 @@
     "clean": "rimraf dist",
     "clean:generated": "rimraf generated",
     "clean:all": "npm run clean && npm run clean:generated",
-    "test": "jest --passWithNoTests",
+    "test": "cross-env NODE_OPTIONS=--experimental-vm-modules jest --passWithNoTests",
     "test:watch": "jest --watch",
     "test:coverage": "jest --coverage",
     "lint": "eslint --config ./eslint.config.js src",
@@ -112,7 +112,7 @@
     "modular"
   ],
   "author": "Tamyla",
-  "license": "GPL-3.0-or-later",
+  "license": "MIT",
   "dependencies": {
     "@iarna/toml": "^2.2.5",
     "chalk": "^5.3.0",
@@ -129,6 +129,7 @@
     "@semantic-release/git": "^10.0.1",
     "@types/node": "^20.19.19",
     "babel-plugin-transform-import-meta": "^2.3.3",
+    "cross-env": "^10.1.0",
     "eslint": "^8.54.0",
     "jest": "^29.7.0",
     "rimraf": "^5.0.10",
@@ -148,6 +149,7 @@
   "homepage": "https://clodo-framework.tamyla.com",
   "release": {
     "branches": [
+      "main",
       "master"
     ],
     "plugins": [

package/templates/generic/src/config/domains.js

@@ -18,9 +18,9 @@ export const domains = {
     accountId: process.env.CLOUDFLARE_ACCOUNT_ID || '', // Configure in setup
     zoneId: process.env.CLOUDFLARE_ZONE_ID || '',       // Configure in setup
     domains: {
-      production: process.env.PRODUCTION_DOMAIN || 'api.{{SERVICE_NAME}}.com',
-      staging: process.env.STAGING_DOMAIN || 'staging-api.{{SERVICE_NAME}}.com',
-      development: process.env.DEVELOPMENT_DOMAIN || 'dev-api.{{SERVICE_NAME}}.com'
+      production: process.env.PRODUCTION_DOMAIN || '{{SERVICE_NAME}}.{{DOMAIN_NAME}}',
+      staging: process.env.STAGING_DOMAIN || '{{SERVICE_NAME}}-staging.{{DOMAIN_NAME}}',
+      development: process.env.DEVELOPMENT_DOMAIN || '{{SERVICE_NAME}}-dev.{{DOMAIN_NAME}}'
     },
     services: [
       '{{SERVICE_NAME}}'