@tamyla/clodo-framework 2.0.17 → 2.0.19

package/CHANGELOG.md

@@ -1,3 +1,19 @@
+## [2.0.19](https://github.com/tamylaa/clodo-framework/compare/v2.0.18...v2.0.19) (2025-10-12)
+
+
+### Bug Fixes
+
+* Add comprehensive deployment configuration implementation status ([025fe82](https://github.com/tamylaa/clodo-framework/commit/025fe821a76ba9ac8cb87d14f2a116a5e8e58c43))
+* Consolidate configuration management and organize documentation ([e3a3d44](https://github.com/tamylaa/clodo-framework/commit/e3a3d448a74b214d75ae669f3a17e3a6ddb36ac4))
+* Resolve ESLint errors in security and config modules ([1080cdb](https://github.com/tamylaa/clodo-framework/commit/1080cdbb69b3ae29158b6af705d8fd376c95da7b))
+
+## [2.0.18](https://github.com/tamylaa/clodo-framework/compare/v2.0.17...v2.0.18) (2025-10-12)
+
+
+### Bug Fixes
+
+* **deployment:** Critical deployment fixes - migrations, worker deployment, status tracking ([23c07e9](https://github.com/tamylaa/clodo-framework/commit/23c07e9a68fa4eb52ccd0df9421eff7d91919cb1)), closes [#2](https://github.com/tamylaa/clodo-framework/issues/2) [#3](https://github.com/tamylaa/clodo-framework/issues/3) [#4](https://github.com/tamylaa/clodo-framework/issues/4)
+
 ## [2.0.17](https://github.com/tamylaa/clodo-framework/compare/v2.0.16...v2.0.17) (2025-10-12)
 
 

package/dist/database/database-orchestrator.js

@@ -628,8 +628,16 @@ export class DatabaseOrchestrator {
   // Command builders and utility methods
 
   buildMigrationCommand(databaseName, environment, isRemote) {
-    const remoteFlag = isRemote ? '--remote' : '--local';
-    return `npx wrangler d1 migrations apply ${databaseName} --env ${environment} ${remoteFlag}`;
+    let command = `npx wrangler d1 migrations apply ${databaseName}`;
+
+    // For remote environments, add --env flag
+    // For local development, use --local WITHOUT --env (wrangler requirement)
+    if (isRemote) {
+      command += ` --env ${environment} --remote`;
+    } else {
+      command += ` --local`;
+    }
+    return command;
   }
   buildBackupCommand(databaseName, environment, backupFile, isRemote) {
     const remoteFlag = isRemote ? '--remote' : '--local';

package/dist/modules/security.js

@@ -1,5 +1,6 @@
 import { ConfigurationValidator } from '../security/ConfigurationValidator.js';
-import { DeploymentManager } from '../security/DeploymentManager.js';
+// DeploymentManager removed - was simulated deployment only
+// Use MultiDomainOrchestrator for real deployments
 import { SecretGenerator } from '../security/SecretGenerator.js';
 import { isValidEnvironment } from '../security/patterns/environment-rules.js';
 
@@ -17,10 +18,16 @@ export const securityModule = {
   generateSecureKey: prefix => SecretGenerator.generateSecureApiKey(32, prefix),
   generateSecureJwtSecret: length => SecretGenerator.generateSecureJwtSecret(length || 64),
   generateServiceKey: (serviceName, env, length) => SecretGenerator.generateServiceKey(serviceName, env, length),
-  // Secure deployment
-  deployWithSecurity: options => DeploymentManager.deployWithSecurity(options),
-  generateSecureConfig: (customer, env) => DeploymentManager.generateSecureConfig(customer, env),
-  validateDeploymentReadiness: (customer, env) => DeploymentManager.validateDeploymentReadiness(customer, env),
+  // Secure deployment (DEPRECATED)
+  deployWithSecurity: () => {
+    throw new Error('deployWithSecurity is deprecated. Use MultiDomainOrchestrator for real deployments.');
+  },
+  generateSecureConfig: () => {
+    throw new Error('generateSecureConfig is deprecated. Use UnifiedConfigManager for configuration.');
+  },
+  validateDeploymentReadiness: () => {
+    throw new Error('validateDeploymentReadiness is deprecated. Use MultiDomainOrchestrator validation.');
+  },
   // Pre-deployment hooks
   hooks: {
     'pre-deployment': async context => {
@@ -43,18 +50,13 @@ export const securityModule = {
         throw new Error('Deployment blocked due to critical security issues');
       }
 
-      // Check deployment readiness
-      const readiness = DeploymentManager.validateDeploymentReadiness(customer, environment);
-      if (!readiness.ready) {
-        console.error('❌ Deployment not ready:');
-        readiness.issues.forEach(issue => console.error(`   - ${issue}`));
-        throw new Error('Deployment blocked due to readiness issues');
-      }
+      // Check deployment readiness (DEPRECATED - commented out)
+      // Use MultiDomainOrchestrator's validation instead
+      console.log('⚠️  DeploymentManager readiness check skipped (deprecated)');
       console.log(`✅ Security validation passed (${issues.length} total issues, ${criticalIssues.length} critical)`);
       return {
         valid: true,
-        issues,
-        readiness
+        issues
       };
     },
     'post-deployment': async context => {
@@ -64,14 +66,14 @@ export const securityModule = {
       } = context;
       console.log(`🔍 Post-deployment security checks for ${customer}/${environment}`);
 
-      // Perform post-deployment validation
-      try {
-        await DeploymentManager.performPostDeploymentChecks(customer, environment);
-        console.log(`✅ Post-deployment checks passed`);
-      } catch (error) {
-        console.error(`❌ Post-deployment checks failed: ${error.message}`);
-        throw error;
-      }
+      // Perform post-deployment validation (DEPRECATED - commented out)
+      // DeploymentManager.performPostDeploymentChecks was simulated only
+      console.log('⚠️  Post-deployment checks skipped (DeploymentManager deprecated)');
+      console.log(`✅ Post-deployment phase complete`);
+      return {
+        success: true,
+        message: 'Post-deployment phase complete (DeploymentManager checks deprecated)'
+      };
     }
   },
   // Utility methods

package/dist/orchestration/modules/DeploymentCoordinator.js

@@ -22,6 +22,38 @@ export class DeploymentCoordinator {
    * @returns {Promise<Object>} Deployment result
    */
   async deploySingleDomain(domain, domainState, handlers) {
+    const phaseResults = {
+      validation: {
+        success: false,
+        errors: [],
+        warnings: []
+      },
+      initialization: {
+        success: false,
+        errors: [],
+        warnings: []
+      },
+      database: {
+        success: false,
+        errors: [],
+        warnings: []
+      },
+      secrets: {
+        success: false,
+        errors: [],
+        warnings: []
+      },
+      deployment: {
+        success: false,
+        errors: [],
+        warnings: []
+      },
+      'post-validation': {
+        success: false,
+        errors: [],
+        warnings: []
+      }
+    };
     try {
       domainState.startTime = new Date();
       domainState.status = 'deploying';
@@ -29,38 +61,105 @@ export class DeploymentCoordinator {
       console.log(`   Deployment ID: ${domainState.deploymentId}`);
       console.log(`   Environment: ${this.environment}`);
       let deploymentUrl = null;
+      let hasCriticalErrors = false;
 
       // Execute deployment phases
       for (const phase of this.deploymentPhases) {
-        const phaseResult = await this.executeDeploymentPhase(domain, phase, domainState, handlers);
-        domainState.phase = `${phase}-complete`;
+        try {
+          const phaseResult = await this.executeDeploymentPhase(domain, phase, domainState, handlers);
+          domainState.phase = `${phase}-complete`;
+
+          // Mark phase as successful
+          phaseResults[phase].success = true;
+
+          // Capture deployment URL from deployment phase
+          if (phase === 'deployment' && phaseResult) {
+            if (phaseResult.url) {
+              deploymentUrl = phaseResult.url;
+            }
+            if (phaseResult.deployed === false) {
+              phaseResults[phase].warnings.push('Worker deployed in dry-run mode');
+            }
+          }
 
-        // Capture deployment URL from deployment phase
-        if (phase === 'deployment' && phaseResult && phaseResult.url) {
-          deploymentUrl = phaseResult.url;
+          // Capture database warnings
+          if (phase === 'database' && phaseResult) {
+            if (phaseResult.error) {
+              phaseResults[phase].warnings.push(phaseResult.error);
+            }
+          }
+        } catch (phaseError) {
+          phaseResults[phase].success = false;
+          phaseResults[phase].errors.push(phaseError.message);
+
+          // Determine if error is critical (stops deployment)
+          const criticalPhases = ['validation', 'initialization', 'deployment'];
+          if (criticalPhases.includes(phase)) {
+            console.error(`   ❌ Critical error in ${phase} phase: ${phaseError.message}`);
+            hasCriticalErrors = true;
+            throw phaseError; // Stop deployment on critical errors
+          } else {
+            // Non-critical errors (database migrations, health checks) - log but continue
+            console.warn(`   ⚠️  ${phase} phase warning: ${phaseError.message}`);
+            console.warn(`   💡 Deployment will continue - this can be fixed manually`);
+          }
         }
       }
-      domainState.status = 'completed';
+
+      // Determine overall success based on phase results
+      const allPhasesSuccessful = Object.values(phaseResults).every(result => result.success);
+      const hasWarnings = Object.values(phaseResults).some(result => result.warnings.length > 0 || result.success === false && result.errors.length === 0);
+      domainState.status = hasCriticalErrors ? 'failed' : allPhasesSuccessful ? 'completed' : 'completed-with-warnings';
       domainState.endTime = new Date();
-      console.log(`   ✅ ${domain} deployed successfully`);
+      domainState.phaseResults = phaseResults;
+
+      // Show appropriate completion message
+      if (allPhasesSuccessful) {
+        console.log(`   ✅ ${domain} deployed successfully`);
+      } else if (!hasCriticalErrors) {
+        console.log(`   ⚠️  ${domain} deployed with warnings`);
+        this.displayPhaseWarnings(phaseResults);
+      }
       return {
         domain,
-        success: true,
+        success: !hasCriticalErrors,
+        allPhasesSuccessful,
         deploymentId: domainState.deploymentId,
         duration: domainState.endTime - domainState.startTime,
         phases: this.deploymentPhases.length,
         url: deploymentUrl || domainState.deploymentUrl,
-        status: 'deployed'
+        status: domainState.status,
+        phaseResults
       };
     } catch (error) {
       domainState.status = 'failed';
       domainState.error = error.message;
       domainState.endTime = new Date();
+      domainState.phaseResults = phaseResults;
       console.error(`   ❌ ${domain} deployment failed: ${error.message}`);
       throw error;
     }
   }
 
+  /**
+   * Display warnings for phases that had issues
+   * @param {Object} phaseResults - Phase results object
+   */
+  displayPhaseWarnings(phaseResults) {
+    console.log(`\n   📊 Phase Status Summary:`);
+    for (const [phase, result] of Object.entries(phaseResults)) {
+      if (result.success && result.warnings.length === 0) {
+        console.log(`   ✅ ${phase}: Success`);
+      } else if (result.success && result.warnings.length > 0) {
+        console.log(`   ⚠️  ${phase}: Success with warnings`);
+        result.warnings.forEach(warn => console.log(`      • ${warn}`));
+      } else {
+        console.log(`   ❌ ${phase}: Failed`);
+        result.errors.forEach(err => console.log(`      • ${err}`));
+      }
+    }
+  }
+
   /**
    * Execute specific deployment phase
    * @param {string} domain - Domain being deployed

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

@@ -12,7 +12,12 @@ import { DeploymentCoordinator } from './modules/DeploymentCoordinator.js';
 import { StateManager } from './modules/StateManager.js';
 import { DatabaseOrchestrator } from '../database/database-orchestrator.js';
 import { EnhancedSecretManager } from '../utils/deployment/secret-generator.js';
+import { WranglerConfigManager } from '../utils/deployment/wrangler-config-manager.js';
 import { ConfigurationValidator } from '../security/ConfigurationValidator.js';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { join } from 'path';
+const execAsync = promisify(exec);
 
 /**
  * Multi-Domain Deployment Orchestrator
@@ -59,6 +64,11 @@ export class MultiDomainOrchestrator {
       projectRoot: this.servicePath,
       dryRun: this.dryRun
     });
+    this.wranglerConfigManager = new WranglerConfigManager({
+      projectRoot: this.servicePath,
+      dryRun: this.dryRun,
+      verbose: options.verbose || false
+    });
 
     // ConfigurationValidator is a static class - don't instantiate
     // Access via ConfigurationValidator.validate() directly
@@ -270,6 +280,24 @@ export class MultiDomainOrchestrator {
         domainState.databaseId = databaseId;
       }
 
+      // CRITICAL: Update wrangler.toml BEFORE attempting migrations
+      console.log(`   📝 Configuring wrangler.toml for database...`);
+      try {
+        // Ensure environment section exists
+        await this.wranglerConfigManager.ensureEnvironment(this.environment);
+
+        // Add database binding (use snake_case for wrangler.toml compatibility)
+        await this.wranglerConfigManager.addDatabaseBinding(this.environment, {
+          binding: 'DB',
+          database_name: databaseName,
+          database_id: databaseId
+        });
+        console.log(`   ✅ wrangler.toml updated with database configuration`);
+      } catch (configError) {
+        console.warn(`   ⚠️  Failed to update wrangler.toml: ${configError.message}`);
+        console.warn(`   💡 You may need to manually add database configuration`);
+      }
+
       // Apply migrations using DatabaseOrchestrator's enterprise capabilities
       console.log(`   🔄 Applying database migrations...`);
       try {
@@ -359,26 +387,109 @@ export class MultiDomainOrchestrator {
   }
 
   /**
-   * Deploy domain worker (returns worker URL)
+   * Deploy domain worker (executes actual wrangler deploy)
    */
   async deployDomainWorker(domain) {
-    // Placeholder: Add actual worker deployment logic here
     console.log(`   🚀 Deploying worker for ${domain}`);
+    if (this.dryRun) {
+      console.log(`   🔍 DRY RUN: Would deploy worker for ${domain}`);
+      const subdomain = this.environment === 'production' ? 'api' : `${this.environment}-api`;
+      return {
+        url: `https://${subdomain}.${domain}`,
+        deployed: false,
+        dryRun: true
+      };
+    }
+    try {
+      // CRITICAL: Ensure environment section exists in wrangler.toml BEFORE deploying
+      console.log(`   📝 Verifying wrangler.toml configuration...`);
+      try {
+        await this.wranglerConfigManager.ensureEnvironment(this.environment);
+      } catch (configError) {
+        console.warn(`   ⚠️  Could not verify wrangler.toml: ${configError.message}`);
+        // Continue anyway - wrangler will provide clearer error if config is wrong
+      }
 
-    // TODO: Execute actual wrangler deploy command here
-    // For now, construct the expected URL from domain and environment
-    const subdomain = this.environment === 'production' ? 'api' : `${this.environment}-api`;
-    const workerUrl = `https://${subdomain}.${domain}`;
+      // Find wrangler.toml in service path
+      const wranglerConfigPath = join(this.servicePath, 'wrangler.toml');
 
-    // Store URL in domain state for later retrieval
-    const domainState = this.portfolioState.domainStates.get(domain);
-    if (domainState) {
-      domainState.deploymentUrl = workerUrl;
+      // Build deploy command with environment
+      let deployCommand = `npx wrangler deploy`;
+
+      // Add environment flag for non-production
+      if (this.environment !== 'production') {
+        deployCommand += ` --env ${this.environment}`;
+      }
+      console.log(`   � Executing: ${deployCommand}`);
+      console.log(`   📁 Working directory: ${this.servicePath}`);
+
+      // Execute deployment with timeout
+      const {
+        stdout,
+        stderr
+      } = await execAsync(deployCommand, {
+        cwd: this.servicePath,
+        timeout: 120000,
+        // 2 minute timeout
+        maxBuffer: 1024 * 1024 * 10 // 10MB buffer for large outputs
+      });
+
+      // Log output for debugging
+      if (stdout) {
+        console.log(`   📄 Deployment output:`);
+        stdout.split('\n').filter(line => line.trim()).forEach(line => {
+          console.log(`     ${line}`);
+        });
+      }
+      if (stderr && !stderr.includes('deprecated')) {
+        console.warn(`   ⚠️  Deployment warnings: ${stderr}`);
+      }
+
+      // Parse worker URL from wrangler output
+      // Wrangler outputs: "Published service-name (version) to https://worker-url"
+      const urlMatch = stdout.match(/https:\/\/[^\s]+/);
+      const workerUrl = urlMatch ? urlMatch[0] : null;
+
+      // Also construct custom domain URL
+      const subdomain = this.environment === 'production' ? 'api' : `${this.environment}-api`;
+      const customUrl = `https://${subdomain}.${domain}`;
+
+      // Store URLs in domain state
+      const domainState = this.portfolioState.domainStates.get(domain);
+      if (domainState) {
+        domainState.workerUrl = workerUrl;
+        domainState.deploymentUrl = customUrl;
+      }
+      if (workerUrl) {
+        console.log(`   ✅ Worker deployed successfully`);
+        console.log(`   🔗 Worker URL: ${workerUrl}`);
+        console.log(`   🔗 Custom URL: ${customUrl}`);
+      } else {
+        console.log(`   ✅ Deployment completed (URL not detected in output)`);
+        console.log(`   🔗 Expected URL: ${customUrl}`);
+      }
+      return {
+        url: customUrl,
+        workerUrl: workerUrl,
+        deployed: true,
+        stdout,
+        stderr
+      };
+    } catch (error) {
+      console.error(`   ❌ Worker deployment failed: ${error.message}`);
+
+      // Parse error for helpful diagnostics
+      if (error.message.includes('wrangler.toml')) {
+        console.error(`   💡 Ensure wrangler.toml exists in ${this.servicePath}`);
+      }
+      if (error.message.includes('No environment found')) {
+        console.error(`   💡 Add [env.${this.environment}] section to wrangler.toml`);
+      }
+      if (error.stderr) {
+        console.error(`   📄 Error details: ${error.stderr}`);
+      }
+      throw new Error(`Worker deployment failed for ${domain}: ${error.message}`);
     }
-    return {
-      url: workerUrl,
-      deployed: true
-    };
   }
 
   /**

package/dist/security/SecurityCLI.js

@@ -5,7 +5,9 @@
 
 import { ConfigurationValidator } from '../security/ConfigurationValidator.js';
 import { SecretGenerator } from '../security/SecretGenerator.js';
-import { DeploymentManager } from '../security/DeploymentManager.js';
+// DeploymentManager removed - was simulated deployment only
+// Use MultiDomainOrchestrator for real deployments
+
 export class SecurityCLI {
   constructor() {
     // Initialize with default settings
@@ -76,6 +78,7 @@ export class SecurityCLI {
 
   /**
    * Deploy with security validation
+   * @deprecated Use MultiDomainOrchestrator for real deployments
    * @param {string} customer - Customer name
    * @param {string} environment - Environment name
    * @param {Object} options - Deployment options
@@ -83,89 +86,29 @@ export class SecurityCLI {
    * @returns {Object} Deployment result
    */
   async deployWithSecurity(customer, environment, options = {}) {
-    try {
-      if (!customer || !environment) {
-        throw new Error('Customer and environment are required');
-      }
-      const result = await DeploymentManager.deployWithSecurity({
-        customer,
-        environment,
-        dryRun: options.dryRun || false
-      });
-      return {
-        success: true,
-        customer,
-        environment,
-        dryRun: options.dryRun,
-        deployed: !options.dryRun,
-        result
-      };
-    } catch (error) {
-      return {
-        success: false,
-        customer,
-        environment,
-        error: error.message
-      };
-    }
+    throw new Error('deployWithSecurity is deprecated. DeploymentManager was simulated deployment only. Use MultiDomainOrchestrator for real deployments.');
   }
 
   /**
    * Generate secure configuration
+   * @deprecated Use UnifiedConfigManager for configuration management
    * @param {string} customer - Customer name
    * @param {string} environment - Environment name
    * @returns {Object} Configuration generation result
    */
   generateSecureConfig(customer, environment) {
-    try {
-      if (!customer || !environment) {
-        throw new Error('Customer and environment are required');
-      }
-      const config = DeploymentManager.generateSecureConfig(customer, environment);
-      return {
-        success: true,
-        customer,
-        environment,
-        config
-      };
-    } catch (error) {
-      return {
-        success: false,
-        customer,
-        environment,
-        error: error.message
-      };
-    }
+    throw new Error('generateSecureConfig is deprecated. Use UnifiedConfigManager for configuration management.');
   }
 
   /**
    * Check deployment readiness
+   * @deprecated Use MultiDomainOrchestrator's validation instead
    * @param {string} customer - Customer name
    * @param {string} environment - Environment name
    * @returns {Object} Readiness check result
    */
   checkDeploymentReadiness(customer, environment) {
-    try {
-      if (!customer || !environment) {
-        throw new Error('Customer and environment are required');
-      }
-      const result = DeploymentManager.validateDeploymentReadiness(customer, environment);
-      return {
-        success: true,
-        customer,
-        environment,
-        ready: result.ready,
-        issues: result.issues || []
-      };
-    } catch (error) {
-      return {
-        success: false,
-        customer,
-        environment,
-        ready: false,
-        error: error.message
-      };
-    }
+    throw new Error('checkDeploymentReadiness is deprecated. Use MultiDomainOrchestrator validation instead.');
   }
 
   /**

package/dist/security/index.js

@@ -4,15 +4,16 @@
  */
 
 import { ConfigurationValidator } from './ConfigurationValidator.js';
-import { DeploymentManager } from './DeploymentManager.js';
+// DeploymentManager removed - replaced by MultiDomainOrchestrator + WranglerConfigManager
 import { SecretGenerator } from './SecretGenerator.js';
 import { ErrorHandler } from '../utils/ErrorHandler.js';
-import { InteractiveDeploymentConfigurator } from '../config/ConfigurationManager.js';
+// InteractiveDeploymentConfigurator removed - replaced by InputCollector
+
 export { ConfigurationValidator } from './ConfigurationValidator.js';
-export { DeploymentManager } from './DeploymentManager.js';
+// export { DeploymentManager } - DEPRECATED: Use MultiDomainOrchestrator instead
 export { SecretGenerator } from './SecretGenerator.js';
 export { ErrorHandler } from '../utils/ErrorHandler.js';
-export { InteractiveDeploymentConfigurator } from '../config/ConfigurationManager.js';
+// export { InteractiveDeploymentConfigurator } - DEPRECATED: Use InputCollector instead
 
 // Re-export patterns and rules for advanced usage
 export { INSECURE_PATTERNS } from './patterns/insecure-patterns.js';
@@ -25,7 +26,7 @@ export function validateSecurity(config, environment = 'production') {
 
 // Main secure deployment function
 export async function deployWithSecurity(options) {
-  return DeploymentManager.deployWithSecurity(options);
+  throw new Error('deployWithSecurity is deprecated. Use MultiDomainOrchestrator instead.');
 }
 
 // Main key generation function
@@ -47,5 +48,5 @@ export function handleDeploymentError(error, context = {}) {
 
 // Main configuration function
 export async function generateConfiguration(defaults = {}) {
-  return InteractiveDeploymentConfigurator.generateFromUserInput(defaults);
+  throw new Error('generateConfiguration is deprecated. Use InputCollector instead.');
 }

package/dist/service-management/ServiceOrchestrator.js

@@ -11,7 +11,7 @@
 import { InputHandler } from './handlers/InputHandler.js';
 import { ConfirmationHandler } from './handlers/ConfirmationHandler.js';
 import { GenerationHandler } from './handlers/GenerationHandler.js';
-import { ConfigMutator } from './handlers/ConfigMutator.js';
+import { WranglerConfigManager } from '../utils/deployment/wrangler-config-manager.js';
 import { ValidationHandler } from './handlers/ValidationHandler.js';
 
 // Legacy imports for backward compatibility
@@ -37,7 +37,7 @@ export class ServiceOrchestrator {
       outputPath: this.outputPath,
       templatePath: this.templatePath
     });
-    this.configMutator = new ConfigMutator();
+    this.wranglerConfigManager = null; // Initialized when needed with specific config path
     this.validationHandler = new ValidationHandler();
 
     // Initialize legacy components for backward compatibility
@@ -398,35 +398,30 @@ export class ServiceOrchestrator {
   }
 
   /**
-   * Update domain configuration using ConfigMutator
+   * Update domain configuration
+   * @deprecated Use WranglerConfigManager directly for wrangler.toml updates
    */
   async updateDomainConfig(servicePath, currentConfig, updates = null) {
-    if (!updates && this.interactive) {
-      // Interactive mode - use confirmation handler
-      const newDomain = await this.confirmationHandler.promptHandler.prompt(`Current domain: ${currentConfig.domainName}\nNew domain name: `);
-      if (!newDomain || newDomain === currentConfig.domainName) {
-        console.log(chalk.yellow('Domain unchanged'));
-        return;
-      }
-      updates = {
-        domainName: newDomain
-      };
-    }
-    return await this.configMutator.updateDomainConfig(servicePath, currentConfig, updates);
+    console.log(chalk.yellow('⚠️  updateDomainConfig is deprecated. Use WranglerConfigManager for wrangler.toml updates.'));
+    throw new Error('updateDomainConfig is deprecated. Please use WranglerConfigManager directly.');
   }
 
   /**
-   * Update Cloudflare configuration using ConfigMutator
+   * Update Cloudflare configuration
+   * @deprecated Use WranglerConfigManager directly for wrangler.toml updates
    */
   async updateCloudflareConfig(servicePath, currentConfig, updates = null) {
-    return await this.configMutator.updateCloudflareConfig(servicePath, currentConfig, updates);
+    console.log(chalk.yellow('⚠️  updateCloudflareConfig is deprecated. Use WranglerConfigManager for wrangler.toml updates.'));
+    throw new Error('updateCloudflareConfig is deprecated. Please use WranglerConfigManager directly.');
   }
 
   /**
-   * Update environment configuration using ConfigMutator
+   * Update environment configuration
+   * @deprecated Use WranglerConfigManager directly for wrangler.toml updates
    */
   async updateEnvironmentConfig(servicePath, currentConfig, updates = null) {
-    return await this.configMutator.updateEnvironmentConfig(servicePath, currentConfig, updates);
+    console.log(chalk.yellow('⚠️  updateEnvironmentConfig is deprecated. Use WranglerConfigManager for wrangler.toml updates.'));
+    throw new Error('updateEnvironmentConfig is deprecated. Please use WranglerConfigManager directly.');
   }
 
   /**