@tamyla/clodo-framework 3.1.14 → 3.1.16

package/dist/bin/commands/deploy.js

@@ -1,12 +1,13 @@
 /**
  * Deploy Command - Smart minimal input deployment with service detection
  * 
- * Input Strategy: SMART MINIMAL
+ * Input Strategy: SMART MINIMAL WITH DOMAIN ROUTING
  * - Detects Clodo services OR legacy services (wrangler.toml)
  * - Supports multiple manifest locations
+ * - Uses DomainRouter for intelligent domain selection
  * - Gathers credentials smartly: env vars → flags → interactive collection with auto-fetch
  * - Validates token and fetches account ID & zone ID from Cloudflare
- * - Integrates with modular-enterprise-deploy.js for clean CLI-based deployment
+ * - REFACTORED (Task 3.2): Integrates with MultiDomainOrchestrator for full deployment orchestration
  */
 
 import chalk from 'chalk';
@@ -14,13 +15,43 @@ import { resolve } from 'path';
 import { ManifestLoader } from '../shared/config/manifest-loader.js';
 import { CloudflareServiceValidator } from '../shared/config/cloudflare-service-validator.js';
 import { DeploymentCredentialCollector } from '../shared/deployment/credential-collector.js';
+import { StandardOptions } from '../shared/utils/cli-options.js';
+import { ConfigLoader } from '../shared/utils/config-loader.js';
+import { DomainRouter } from '../shared/routing/domain-router.js';
+import { MultiDomainOrchestrator } from "../../orchestration/multi-domain-orchestrator.js";
 export function registerDeployCommand(program) {
-  program.command('deploy').description('Deploy a Clodo service with smart credential handling').option('--token <token>', 'Cloudflare API token').option('--account-id <id>', 'Cloudflare account ID').option('--zone-id <id>', 'Cloudflare zone ID').option('--dry-run', 'Simulate deployment without making changes').option('--quiet', 'Quiet mode - minimal output').option('--service-path <path>', 'Path to service directory', '.').action(async options => {
+  const command = program.command('deploy').description('Deploy a Clodo service with smart credential handling and domain selection')
+  // Cloudflare-specific options
+  .option('--token <token>', 'Cloudflare API token').option('--account-id <id>', 'Cloudflare account ID').option('--zone-id <id>', 'Cloudflare zone ID').option('--domain <domain>', 'Specific domain to deploy to (otherwise prompted if multiple exist)').option('--environment <env>', 'Target environment (development, staging, production)', 'production').option('--all-domains', 'Deploy to all configured domains (ignores --domain flag)').option('--dry-run', 'Simulate deployment without making changes').option('--service-path <path>', 'Path to service directory', '.');
+
+  // Add standard options (--verbose, --quiet, --json, --no-color, --config-file)
+  StandardOptions.define(command).action(async options => {
     try {
-      console.log(chalk.cyan('\n🚀 Clodo Service Deployment\n'));
+      const output = new (await import('../shared/utils/output-formatter.js')).OutputFormatter(options);
+      const configLoader = new ConfigLoader({
+        verbose: options.verbose,
+        quiet: options.quiet,
+        json: options.json
+      });
+
+      // Load config from file if specified
+      let configFileData = {};
+      if (options.configFile) {
+        configFileData = configLoader.loadSafe(options.configFile, {});
+        if (options.verbose && !options.quiet) {
+          output.info(`Loaded configuration from: ${options.configFile}`);
+        }
+      }
+
+      // Substitute environment variables in config
+      configFileData = configLoader.substituteEnvironmentVariables(configFileData);
+
+      // Merge config file defaults with CLI options (CLI takes precedence)
+      const mergedOptions = configLoader.merge(configFileData, options);
+      output.info('🚀 Clodo Service Deployment');
 
       // Step 1: Load and validate service configuration
-      const servicePath = resolve(options.servicePath);
+      const servicePath = resolve(mergedOptions.servicePath || '.');
       const serviceConfig = await ManifestLoader.loadAndValidateCloudflareService(servicePath);
       if (!serviceConfig.manifest) {
         if (serviceConfig.error === 'NOT_A_CLOUDFLARE_SERVICE') {
@@ -37,7 +68,7 @@ export function registerDeployCommand(program) {
         CloudflareServiceValidator.printValidationReport(serviceConfig.validationResult.validation);
       }
       ManifestLoader.printManifestInfo(serviceConfig.manifest);
-      console.log(chalk.gray(`Configuration loaded from: ${serviceConfig.foundAt}\n`));
+      output.info(`Configuration loaded from: ${serviceConfig.foundAt}`);
 
       // Step 2: Smart credential gathering with interactive collection
       // Uses DeploymentCredentialCollector which:
@@ -47,126 +78,246 @@ export function registerDeployCommand(program) {
       // - Caches credentials for future use
       const credentialCollector = new DeploymentCredentialCollector({
         servicePath: servicePath,
-        quiet: options.quiet
+        quiet: mergedOptions.quiet
       });
       let credentials;
       try {
         credentials = await credentialCollector.collectCredentials({
-          token: options.token,
-          accountId: options.accountId,
-          zoneId: options.zoneId
+          token: mergedOptions.token,
+          accountId: mergedOptions.accountId,
+          zoneId: mergedOptions.zoneId
         });
       } finally {
         credentialCollector.cleanup();
       }
 
-      // Step 3: Extract configuration from manifest
+      // Step 3: Initialize DomainRouter for intelligent domain selection
+      // REFACTORED (Task 3.2): Use DomainRouter for domain detection and selection
+      console.log(chalk.cyan('\n🗺️  Detecting available domains...\n'));
+      const router = new DomainRouter({
+        environment: mergedOptions.environment || 'production',
+        verbose: options.verbose,
+        configPath: options.configPath,
+        disableOrchestrator: false,
+        // We'll use the orchestrator for deployment
+        orchestratorOptions: {
+          dryRun: options.dryRun || false,
+          cloudflareToken: credentials.token,
+          cloudflareAccountId: credentials.accountId
+        }
+      });
+
+      // Detect domains from manifest
+      let detectedDomains = [];
       const manifest = serviceConfig.manifest;
       const config = manifest.deployment || manifest.configuration || {};
+      const domainsConfig = config.domains || [];
+      if (Array.isArray(domainsConfig) && domainsConfig.length > 0) {
+        // Handle both array of strings and array of objects
+        detectedDomains = domainsConfig.map(d => {
+          if (typeof d === 'string') return d;
+          if (typeof d === 'object' && d.name) return d.name;
+          return null;
+        }).filter(d => d !== null);
+      }
+
+      // If no domains in config, try to detect from environment
+      if (detectedDomains.length === 0 && manifest._source === 'cloudflare-service-detected') {
+        // For detected CF services, use default
+        detectedDomains = ['workers.cloudflare.com'];
+      }
+
+      // Domain selection: check CLI flag first, then prompt user
+      let selectedDomain = mergedOptions.domain;
+      if (!selectedDomain && detectedDomains.length > 0) {
+        if (detectedDomains.length === 1) {
+          // Only one domain, use it directly
+          selectedDomain = detectedDomains[0];
+          if (!options.quiet) {
+            console.log(chalk.green(`✓ Selected domain: ${selectedDomain}`));
+          }
+        } else {
+          // Multiple domains available - let user choose
+          console.log(chalk.cyan('📍 Available domains:'));
+          detectedDomains.forEach((d, i) => {
+            console.log(chalk.white(`  ${i + 1}) ${d}`));
+          });
+
+          // If running interactively, prompt user
+          if (process.stdin.isTTY) {
+            const {
+              createPromptModule
+            } = await import('inquirer');
+            const prompt = createPromptModule();
+            const response = await prompt([{
+              type: 'list',
+              name: 'selectedDomain',
+              message: 'Select domain to deploy to:',
+              choices: detectedDomains,
+              default: detectedDomains[0]
+            }]);
+            selectedDomain = response.selectedDomain;
+          } else {
+            // Non-interactive mode: use first domain
+            selectedDomain = detectedDomains[0];
+            console.log(chalk.yellow(`⚠️  Non-interactive mode: using first domain: ${selectedDomain}`));
+          }
+        }
+      }
+      if (!selectedDomain) {
+        if (!options.quiet) {
+          console.error(chalk.yellow('⚠️  No domain configured for deployment'));
+          console.error(chalk.gray('For Clodo services: add deployment.domains in clodo-service-manifest.json'));
+          console.error(chalk.gray('For detected CF services: define routes in wrangler.toml'));
+        }
+        process.exit(1);
+      }
+
+      // Step 4: Validate domain configuration
+      console.log(chalk.cyan('\n🔍 Validating domain configuration...\n'));
+      const validation = router.validateConfiguration({
+        domains: [selectedDomain],
+        environment: mergedOptions.environment || 'production'
+      });
+      if (!validation.valid) {
+        console.error(chalk.red('❌ Configuration validation failed:'));
+        validation.errors.forEach(err => {
+          console.error(chalk.yellow(`  • ${err}`));
+        });
+        process.exit(1);
+      }
+      if (validation.warnings && validation.warnings.length > 0) {
+        console.log(chalk.yellow('⚠️  Configuration warnings:'));
+        validation.warnings.forEach(warn => {
+          console.log(chalk.gray(`  • ${warn}`));
+        });
+      }
 
       // Extract service metadata
       const serviceName = manifest.serviceName || 'unknown-service';
       const serviceType = manifest.serviceType || 'generic';
 
-      // For detected Cloudflare services, domain comes from wrangler.toml or environment
-      // For Clodo services, use first domain if available
-      let domain = null;
-      const domains = config.domains || [];
-      if (domains.length > 0) {
-        // Clodo service with multiple domains
-        domain = domains[0].name || domains[0];
-      } else if (manifest._source === 'cloudflare-service-detected') {
-        // Detected CF service - get domain from route or config
-        // For now, use a placeholder since we don't have explicit domain routing in detected services
-        domain = 'workers.cloudflare.com';
-        console.log(chalk.gray('Note: Using Cloudflare Workers default domain (add routes in wrangler.toml for custom domains)'));
-      }
-      if (!domain && !options.quiet) {
-        console.error(chalk.yellow('⚠️  No domain configured for deployment'));
-        console.error(chalk.gray('For Clodo services: add deployment.domains in clodo-service-manifest.json'));
-        console.error(chalk.gray('For detected CF services: define routes in wrangler.toml'));
-      }
-      console.log(chalk.cyan('📋 Deployment Plan:'));
-      console.log(chalk.gray('─'.repeat(50)));
-      console.log(chalk.white(`Service:  ${serviceName}`));
-      console.log(chalk.white(`Type:     ${serviceType}`));
-      if (domain) {
-        console.log(chalk.white(`Domain:   ${domain}`));
-      }
-      console.log(chalk.white(`Account:  ${credentials.accountId.substring(0, 8)}...`));
-      console.log(chalk.white(`Zone:     ${credentials.zoneId.substring(0, 8)}...`));
-      console.log(chalk.gray('─'.repeat(50)));
+      // Display deployment plan
+      console.log(chalk.cyan('\n📋 Deployment Plan:'));
+      console.log(chalk.gray('─'.repeat(60)));
+      console.log(chalk.white(`Service:         ${serviceName}`));
+      console.log(chalk.white(`Type:            ${serviceType}`));
+      console.log(chalk.white(`Domain:          ${selectedDomain}`));
+      console.log(chalk.white(`Environment:     ${mergedOptions.environment || 'production'}`));
+      console.log(chalk.white(`Account:         ${credentials.accountId.substring(0, 8)}...`));
+      console.log(chalk.white(`Zone:            ${credentials.zoneId.substring(0, 8)}...`));
+      console.log(chalk.white(`Deployment Mode: ${options.dryRun ? 'DRY RUN' : 'LIVE'}`));
+      console.log(chalk.gray('─'.repeat(60)));
       if (options.dryRun) {
         console.log(chalk.yellow('\n🔍 DRY RUN MODE - No changes will be made\n'));
       }
 
-      // Step 4: Load and call modular deployer
-      console.log(chalk.cyan('\n⚙️  Initializing deployment system...\n'));
-      let ModularEnterpriseDeployer;
+      // Step 5: Initialize MultiDomainOrchestrator for deployment
+      // REFACTORED (Task 3.2): Direct orchestrator integration instead of external deployer
+      console.log(chalk.cyan('\n⚙️  Initializing orchestration system...\n'));
+      const orchestrator = new MultiDomainOrchestrator({
+        domains: [selectedDomain],
+        environment: mergedOptions.environment || 'production',
+        dryRun: options.dryRun || false,
+        skipTests: false,
+        parallelDeployments: 1,
+        // Single domain in this flow
+        servicePath: servicePath,
+        cloudflareToken: credentials.token,
+        cloudflareAccountId: credentials.accountId,
+        enablePersistence: !options.dryRun,
+        rollbackEnabled: !options.dryRun,
+        verbose: options.verbose
+      });
       try {
-        const module = await import('../../deployment/modular-enterprise-deploy.js');
-        ModularEnterpriseDeployer = module.ModularEnterpriseDeployer || module.default;
+        await orchestrator.initialize();
       } catch (err) {
-        console.error(chalk.red('❌ Failed to load deployment system'));
+        console.error(chalk.red('❌ Failed to initialize orchestrator'));
         console.error(chalk.yellow(`Error: ${err.message}`));
         if (process.env.DEBUG) {
           console.error(chalk.gray(err.stack));
         }
         process.exit(1);
       }
-      if (!ModularEnterpriseDeployer) {
-        console.error(chalk.red('❌ ModularEnterpriseDeployer not found in deployment module'));
-        process.exit(1);
-      }
 
-      // Create deployer instance with gathered credentials
-      const deployer = new ModularEnterpriseDeployer({
-        apiToken: credentials.token,
-        accountId: credentials.accountId,
-        zoneId: credentials.zoneId,
-        domain: domain,
-        dryRun: options.dryRun,
-        quiet: options.quiet,
-        servicePath: servicePath,
-        serviceName: serviceName,
-        serviceType: serviceType
-      });
+      // Step 6: Execute deployment via orchestrator
+      console.log(chalk.cyan('🚀 Starting deployment via orchestrator...\n'));
+      let result;
+      try {
+        result = await orchestrator.deploySingleDomain(selectedDomain, {
+          manifest: manifest,
+          credentials: credentials,
+          dryRun: options.dryRun,
+          environment: mergedOptions.environment || 'production'
+        });
+      } catch (deployError) {
+        console.error(chalk.red('\n❌ Deployment failed during orchestration\n'));
+        console.error(chalk.yellow(`Error: ${deployError.message}`));
 
-      // Run deployment
-      console.log(chalk.cyan('🚀 Starting deployment...\n'));
-      const result = await deployer.run({
-        manifest: manifest,
-        credentials: credentials,
-        dryRun: options.dryRun
-      });
+        // Provide helpful error context
+        if (deployError.message.includes('credentials') || deployError.message.includes('auth')) {
+          console.error(chalk.yellow('\n💡 Credential Issue:'));
+          console.error(chalk.white('  Check your API token, account ID, and zone ID'));
+          console.error(chalk.white('  Visit: https://dash.cloudflare.com/profile/api-tokens'));
+        }
+        if (deployError.message.includes('domain') || deployError.message.includes('zone')) {
+          console.error(chalk.yellow('\n� Domain Issue:'));
+          console.error(chalk.white('  Verify domain exists in Cloudflare'));
+          console.error(chalk.white('  Check API token has zone:read permissions'));
+        }
+        if (process.env.DEBUG) {
+          console.error(chalk.gray('\nFull Stack Trace:'));
+          console.error(chalk.gray(deployError.stack));
+        }
+        process.exit(1);
+      }
 
-      // Display results
+      // Step 7: Display deployment results
       console.log(chalk.green('\n✅ Deployment Completed Successfully!\n'));
-      console.log(chalk.gray('─'.repeat(50)));
+      console.log(chalk.gray('─'.repeat(60)));
+
+      // Display results from orchestrator
       if (result.url) {
-        console.log(chalk.white(`🌐 Service URL: ${chalk.bold(result.url)}`));
+        console.log(chalk.white(`🌐 Service URL:     ${chalk.bold(result.url)}`));
       }
-      console.log(chalk.white(`📦 Service: ${serviceName}`));
-      console.log(chalk.white(`🔧 Type: ${serviceType}`));
-      console.log(chalk.white(`🌍 Domain: ${domain}`));
+      console.log(chalk.white(`📦 Service:         ${serviceName}`));
+      console.log(chalk.white(`🔧 Type:            ${serviceType}`));
+      console.log(chalk.white(`🌍 Domain:          ${selectedDomain}`));
+      console.log(chalk.white(`🌎 Environment:     ${mergedOptions.environment || 'production'}`));
       if (result.workerId) {
-        console.log(chalk.white(`👤 Worker ID: ${result.workerId}`));
+        console.log(chalk.white(`👤 Worker ID:       ${result.workerId}`));
+      }
+      if (result.deploymentId) {
+        console.log(chalk.white(`📋 Deployment ID:   ${result.deploymentId}`));
       }
       if (result.status) {
         const statusColor = result.status.toLowerCase().includes('success') ? chalk.green : chalk.yellow;
-        console.log(chalk.white(`📊 Status: ${statusColor(result.status)}`));
+        console.log(chalk.white(`📊 Status:          ${statusColor(result.status)}`));
+      }
+
+      // Display audit information if available
+      if (result.auditLog) {
+        console.log(chalk.cyan('\n📋 Deployment Audit:'));
+        console.log(chalk.gray(`  Started:  ${result.auditLog.startTime}`));
+        console.log(chalk.gray(`  Completed: ${result.auditLog.endTime}`));
+        console.log(chalk.gray(`  Duration: ${result.auditLog.duration}ms`));
       }
-      console.log(chalk.gray('─'.repeat(50)));
+      console.log(chalk.gray('─'.repeat(60)));
 
-      // Next steps
+      // Display next steps
       if (!options.dryRun) {
         console.log(chalk.cyan('\n💡 Next Steps:'));
-        console.log(chalk.white('  • Test deployment: curl ' + (result.url || `https://${domain}`)));
-        console.log(chalk.white('  • View logs: wrangler tail ' + serviceName));
-        console.log(chalk.white('  • Monitor: https://dash.cloudflare.com'));
+        console.log(chalk.white(`  • Test deployment: curl ${result.url || `https://${selectedDomain}`}`));
+        console.log(chalk.white(`  • View logs: wrangler tail ${serviceName}`));
+        console.log(chalk.white(`  • Monitor: https://dash.cloudflare.com`));
+        console.log(chalk.white(`  • Check audit logs: See deployment ID above\n`));
+      } else {
+        console.log(chalk.cyan('\n💡 Dry Run Complete'));
+        console.log(chalk.white(`  • Review the plan above`));
+        console.log(chalk.white(`  • Remove --dry-run to execute deployment\n`));
       }
       if (process.env.DEBUG && result.details) {
-        console.log(chalk.gray('\n📋 Full Result:'));
+        console.log(chalk.gray('📋 Full Result:'));
         console.log(chalk.gray(JSON.stringify(result, null, 2)));
       }
     } catch (error) {
@@ -176,11 +327,16 @@ export function registerDeployCommand(program) {
         console.error(chalk.white('  Check your API token, account ID, and zone ID'));
         console.error(chalk.white('  Visit: https://dash.cloudflare.com/profile/api-tokens'));
       }
-      if (error.message.includes('domain')) {
+      if (error.message.includes('domain') || error.message.includes('zone')) {
         console.error(chalk.yellow('\n💡 Domain Issue:'));
         console.error(chalk.white('  Verify domain exists in Cloudflare'));
         console.error(chalk.white('  Check API token has zone:read permissions'));
       }
+      if (error.message.includes('orchestration') || error.message.includes('initialization')) {
+        console.error(chalk.yellow('\n💡 Orchestration Issue:'));
+        console.error(chalk.white('  Check MultiDomainOrchestrator configuration'));
+        console.error(chalk.white('  Verify all modular components loaded correctly'));
+      }
       if (process.env.DEBUG) {
         console.error(chalk.gray('\nFull Stack Trace:'));
         console.error(chalk.gray(error.stack));

package/dist/bin/commands/diagnose.js

@@ -1,61 +1,73 @@
-/**
- * Diagnose Command - Diagnose and report issues with an existing service
- */
-
 import chalk from 'chalk';
 import { ServiceOrchestrator } from "../../service-management/ServiceOrchestrator.js";
+import { StandardOptions } from '../shared/utils/cli-options.js';
+import { ConfigLoader } from '../shared/utils/config-loader.js';
 export function registerDiagnoseCommand(program) {
-  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').action(async (servicePath, options) => {
+  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');
+
+  // Add standard options (--verbose, --quiet, --json, --no-color, --config-file)
+  StandardOptions.define(command).action(async (servicePath, options) => {
     try {
+      const output = new (await import('../shared/utils/output-formatter.js')).OutputFormatter(options);
+      const configLoader = new ConfigLoader({
+        verbose: options.verbose,
+        quiet: options.quiet,
+        json: options.json
+      });
+
+      // Load config from file if specified
+      let configFileData = {};
+      if (options.configFile) {
+        configFileData = configLoader.loadSafe(options.configFile, {});
+        if (options.verbose && !options.quiet) {
+          output.info(`Loaded configuration from: ${options.configFile}`);
+        }
+      }
+
+      // Merge config file defaults with CLI options (CLI takes precedence)
+      const mergedOptions = configLoader.merge(configFileData, options);
       const orchestrator = new ServiceOrchestrator();
 
       // Auto-detect service path if not provided
       if (!servicePath) {
         servicePath = await orchestrator.detectServicePath();
         if (!servicePath) {
-          console.error(chalk.red('No service path provided and could not auto-detect service directory'));
+          output.error('No service path provided and could not auto-detect service directory');
           process.exit(1);
         }
       }
-      console.log(chalk.cyan('🔍 Diagnosing service...'));
-      const diagnosis = await orchestrator.diagnoseService(servicePath, options);
+      output.info('🔍 Diagnosing service...');
+      const diagnosis = await orchestrator.diagnoseService(servicePath, mergedOptions);
 
       // Display results
-      console.log(chalk.cyan('\n📋 Diagnostic Report'));
-      console.log(chalk.white(`Service: ${diagnosis.serviceName || 'Unknown'}`));
-      console.log(chalk.white(`Path: ${servicePath}`));
+      output.section('Diagnostic Report');
+      output.list([`Service: ${diagnosis.serviceName || 'Unknown'}`, `Path: ${servicePath}`]);
       if (diagnosis.errors.length > 0) {
-        console.log(chalk.red('\n❌ Critical Errors:'));
+        output.warning('❌ Critical Errors:');
         diagnosis.errors.forEach(error => {
-          console.log(chalk.red(`  • ${error.message}`));
-          if (error.location) {
-            console.log(chalk.gray(`    Location: ${error.location}`));
-          }
-          if (error.suggestion) {
-            console.log(chalk.cyan(`    💡 ${error.suggestion}`));
-          }
+          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) {
-        console.log(chalk.yellow('\n⚠️  Warnings:'));
+        output.warning('⚠️  Warnings:');
         diagnosis.warnings.forEach(warning => {
-          console.log(chalk.yellow(`  • ${warning.message}`));
-          if (warning.suggestion) {
-            console.log(chalk.cyan(`    💡 ${warning.suggestion}`));
-          }
+          let msg = `• ${warning.message}`;
+          if (warning.suggestion) msg += ` 💡 ${warning.suggestion}`;
+          output.warning(msg);
         });
       }
       if (diagnosis.recommendations.length > 0) {
-        console.log(chalk.cyan('\n💡 Recommendations:'));
-        diagnosis.recommendations.forEach(rec => {
-          console.log(chalk.white(`  • ${rec}`));
-        });
+        output.info('💡 Recommendations:');
+        output.list(diagnosis.recommendations);
       }
 
       // Export report if requested
-      if (options.exportReport) {
-        await orchestrator.exportDiagnosticReport(diagnosis, options.exportReport);
-        console.log(chalk.green(`\n📄 Report exported to: ${options.exportReport}`));
+      if (mergedOptions.exportReport) {
+        await orchestrator.exportDiagnosticReport(diagnosis, mergedOptions.exportReport);
+        output.success(`📄 Report exported to: ${mergedOptions.exportReport}`);
       }
 
       // Exit with error code if critical issues found
@@ -63,7 +75,8 @@ export function registerDiagnoseCommand(program) {
         process.exit(1);
       }
     } catch (error) {
-      console.error(chalk.red(`Diagnosis failed: ${error.message}`));
+      const output = new (await import('../shared/utils/output-formatter.js')).OutputFormatter(options || {});
+      output.error(`Diagnosis failed: ${error.message}`);
       process.exit(1);
     }
   });

package/dist/bin/commands/update.js

@@ -4,50 +4,70 @@
 
 import chalk from 'chalk';
 import { ServiceOrchestrator } from "../../service-management/ServiceOrchestrator.js";
+import { StandardOptions } from '../shared/utils/cli-options.js';
+import { ConfigLoader } from '../shared/utils/config-loader.js';
 export function registerUpdateCommand(program) {
-  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').action(async (servicePath, options) => {
+  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('--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('../shared/utils/output-formatter.js')).OutputFormatter(options);
+      const configLoader = new ConfigLoader({
+        verbose: options.verbose,
+        quiet: options.quiet,
+        json: options.json
+      });
+
+      // Load config from file if specified
+      let configFileData = {};
+      if (options.configFile) {
+        configFileData = configLoader.loadSafe(options.configFile, {});
+        if (options.verbose && !options.quiet) {
+          output.info(`Loaded configuration from: ${options.configFile}`);
+        }
+      }
+
+      // Merge config file defaults with CLI options (CLI takes precedence)
+      const mergedOptions = configLoader.merge(configFileData, options);
       const orchestrator = new ServiceOrchestrator();
 
       // Auto-detect service path if not provided
       if (!servicePath) {
         servicePath = await orchestrator.detectServicePath();
         if (!servicePath) {
-          console.error(chalk.red('No service path provided and could not auto-detect service directory'));
-          console.log(chalk.white('Please run this command from within a service directory or specify the path'));
+          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);
         }
-        console.log(chalk.cyan(`Auto-detected service at: ${servicePath}`));
+        output.info(`Auto-detected service at: ${servicePath}`);
       }
 
       // Validate it's a service directory
       const isValid = await orchestrator.validateService(servicePath);
       if (!isValid.valid) {
-        console.log(chalk.yellow('⚠️  Service has configuration issues. Use --fix-errors to attempt automatic fixes.'));
-        if (!options.fixErrors) {
-          console.log(chalk.white('Issues found:'));
-          isValid.issues.forEach(issue => {
-            console.log(chalk.yellow(`  • ${issue}`));
-          });
+        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 (options.interactive) {
+      if (mergedOptions.interactive) {
         await orchestrator.runInteractiveUpdate(servicePath);
       } else {
-        await orchestrator.runNonInteractiveUpdate(servicePath, options);
+        await orchestrator.runNonInteractiveUpdate(servicePath, mergedOptions);
       }
-      console.log(chalk.green('\n✓ Service update completed successfully!'));
+      output.success('Service update completed successfully!');
     } catch (error) {
-      console.error(chalk.red(`\n✗ Service update failed: ${error.message}`));
+      const output = new (await import('../shared/utils/output-formatter.js')).OutputFormatter(options || {});
+      output.error(`Service update failed: ${error.message}`);
       if (error.details) {
-        console.error(chalk.yellow(`Details: ${error.details}`));
+        output.warning(`Details: ${error.details}`);
       }
       if (error.recovery) {
-        console.log(chalk.cyan('\n💡 Recovery suggestions:'));
-        error.recovery.forEach(suggestion => {
-          console.log(chalk.white(`  • ${suggestion}`));
-        });
+        output.info('Recovery suggestions:');
+        output.list(error.recovery);
       }
       process.exit(1);
     }