@tamyla/clodo-framework 3.1.8 → 3.1.10

package/dist/bin/clodo-service-test.js

@@ -0,0 +1,10 @@
+import { Command } from 'commander';
+const program = new Command();
+program.name('clodo-service-test').description('Test Clodo Framework CLI').version('1.0.0');
+program.command('hello').description('Say hello').action(() => {
+  console.log('Hello from Clodo Service CLI!');
+});
+program.command('create').description('Create a new service').action(() => {
+  console.log('Create command would run here...');
+});
+program.parse();

package/dist/bin/clodo-service.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+
+/**
+ * Clodo Framework - Unified Service Management CLI
+ *
+ * Main entry point that registers and orchestrates all service management commands.
+ * Each command is in its own module in bin/commands/ for clean separation of concerns.
+ *
+ * Commands:
+ * - create      Create a new Clodo service with conversational setup
+ * - deploy      Deploy a Clodo service with smart credential handling
+ * - validate    Validate an existing service configuration
+ * - update      Update an existing service configuration
+ * - diagnose    Diagnose and report issues with an existing service
+ * - assess      Run intelligent capability assessment
+ * - list-types  List available service types and their features
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+
+// Import command registration functions
+import { registerCreateCommand } from './commands/create.js';
+import { registerDeployCommand } from './commands/deploy.js';
+import { registerValidateCommand } from './commands/validate.js';
+import { registerUpdateCommand } from './commands/update.js';
+import { registerDiagnoseCommand } from './commands/diagnose.js';
+import { registerAssessCommand } from './commands/assess.js';
+
+// Create program instance
+const program = new Command();
+program.name('clodo-service').description('Unified conversational CLI for Clodo Framework service lifecycle management').version('1.0.0');
+
+// Register all command modules
+registerCreateCommand(program);
+registerDeployCommand(program);
+registerValidateCommand(program);
+registerUpdateCommand(program);
+registerDiagnoseCommand(program);
+registerAssessCommand(program);
+
+// List available service types
+program.command('list-types').description('List available service types and their features').action(() => {
+  console.log(chalk.cyan('Available Clodo Framework Service Types:'));
+  console.log('');
+  const types = {
+    'data-service': ['Authentication', 'Authorization', 'File Storage', 'Search', 'Filtering', 'Pagination'],
+    'auth-service': ['Authentication', 'Authorization', 'User Profiles', 'Email Notifications', 'Magic Link Auth'],
+    'content-service': ['File Storage', 'Search', 'Filtering', 'Pagination', 'Caching'],
+    'api-gateway': ['Authentication', 'Authorization', 'Rate Limiting', 'Caching', 'Monitoring'],
+    'generic': ['Logging', 'Monitoring', 'Error Reporting']
+  };
+  Object.entries(types).forEach(([type, features]) => {
+    console.log(chalk.green(`  ${type}`));
+    features.forEach(feature => {
+      console.log(chalk.white(`    • ${feature}`));
+    });
+    console.log('');
+  });
+});
+
+// Parse command line arguments
+program.parse();

package/dist/bin/commands/assess.js

@@ -0,0 +1,76 @@
+/**
+ * Assess Command - Run intelligent capability assessment
+ * Requires @tamyla/clodo-orchestration package for professional edition
+ */
+
+import chalk from 'chalk';
+export function registerAssessCommand(program) {
+  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) {
+        const {
+          writeFileSync
+        } = await import('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);
+    }
+  });
+}

package/dist/bin/commands/create.js

@@ -0,0 +1,56 @@
+/**
+ * Create Command - Create a new Clodo service with conversational setup
+ * 
+ * Input Strategy: FULL three-tier collection (88 fields)
+ * Uses ServiceOrchestrator to collect all required information interactively
+ */
+
+import chalk from 'chalk';
+import { ServiceOrchestrator } from '../../src/service-management/ServiceOrchestrator.js';
+export function registerCreateCommand(program) {
+  program.command('create').description('Create a new Clodo service with conversational setup').option('-n, --non-interactive', 'Run in non-interactive mode with all required parameters').option('--service-name <name>', 'Service name (required in non-interactive mode)').option('--service-type <type>', 'Service type: data-service, auth-service, content-service, api-gateway, generic', 'generic').option('--domain-name <domain>', 'Domain name (required in non-interactive mode)').option('--cloudflare-token <token>', 'Cloudflare API token (required in non-interactive mode)').option('--cloudflare-account-id <id>', 'Cloudflare account ID (required in non-interactive mode)').option('--cloudflare-zone-id <id>', 'Cloudflare zone ID (required in non-interactive mode)').option('--environment <env>', 'Target environment: development, staging, production', 'development').option('--output-path <path>', 'Output directory for generated service', '.').option('--template-path <path>', 'Path to service templates', './templates').action(async options => {
+    try {
+      const orchestrator = new ServiceOrchestrator({
+        interactive: !options.nonInteractive,
+        outputPath: options.outputPath,
+        templatePath: options.templatePath
+      });
+      if (options.nonInteractive) {
+        // Validate required parameters for non-interactive mode
+        const required = ['serviceName', 'domainName', 'cloudflareToken', 'cloudflareAccountId', 'cloudflareZoneId'];
+        const missing = required.filter(key => !options[key]);
+        if (missing.length > 0) {
+          console.error(chalk.red(`Missing required parameters: ${missing.join(', ')}`));
+          console.error(chalk.yellow('Use --help for parameter details'));
+          process.exit(1);
+        }
+
+        // Convert CLI options to core inputs
+        const coreInputs = {
+          serviceName: options.serviceName,
+          serviceType: options.serviceType,
+          domainName: options.domainName,
+          cloudflareToken: options.cloudflareToken,
+          cloudflareAccountId: options.cloudflareAccountId,
+          cloudflareZoneId: options.cloudflareZoneId,
+          environment: options.environment
+        };
+        await orchestrator.runNonInteractive(coreInputs);
+      } else {
+        await orchestrator.runInteractive();
+      }
+      console.log(chalk.green('\n✓ Service creation completed successfully!'));
+      console.log(chalk.cyan('Next steps:'));
+      console.log(chalk.white('  1. cd into your new service directory'));
+      console.log(chalk.white('  2. Run npm install'));
+      console.log(chalk.white('  3. Configure additional settings in src/config/domains.js'));
+      console.log(chalk.white('  4. Run npm run deploy to deploy to Cloudflare'));
+    } catch (error) {
+      console.error(chalk.red(`\n✗ Service creation failed: ${error.message}`));
+      if (error.details) {
+        console.error(chalk.yellow(`Details: ${error.details}`));
+      }
+      process.exit(1);
+    }
+  });
+}

package/dist/bin/commands/deploy.js

@@ -0,0 +1,196 @@
+/**
+ * Deploy Command - Smart minimal input deployment with service detection
+ * 
+ * Input Strategy: SMART MINIMAL
+ * - Detects if project is a service (clodo-service-manifest.json)
+ * - Gathers credentials smartly: env vars → flags → fail with helpful message (never prompt)
+ * - Integrates with modular-enterprise-deploy.js for clean CLI-based deployment
+ */
+
+import chalk from 'chalk';
+import { existsSync, readFileSync } from 'fs';
+import { resolve, join } from 'path';
+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 => {
+    try {
+      console.log(chalk.cyan('\n🚀 Clodo Service Deployment\n'));
+
+      // Step 1: Detect if this is a service project
+      const servicePath = resolve(options.servicePath);
+      const manifestPath = join(servicePath, 'clodo-service-manifest.json');
+      if (!existsSync(manifestPath)) {
+        console.error(chalk.red('❌ This is not a Clodo service project'));
+        console.error(chalk.yellow('\nExpected to find: clodo-service-manifest.json'));
+        console.error(chalk.cyan('\nAre you trying to deploy the framework itself?'));
+        console.error(chalk.white('The clodo-framework repository is a library, not deployable.'));
+        console.error(chalk.white('Create a service first: npx clodo-service create'));
+        process.exit(1);
+      }
+
+      // Read service manifest
+      let manifest;
+      try {
+        const manifestContent = readFileSync(manifestPath, 'utf8');
+        manifest = JSON.parse(manifestContent);
+      } catch (err) {
+        console.error(chalk.red('❌ Failed to read service manifest'));
+        console.error(chalk.yellow(`Error: ${err.message}`));
+        process.exit(1);
+      }
+      const serviceName = manifest.serviceName || 'unknown-service';
+      const serviceType = manifest.serviceType || 'unknown-type';
+      console.log(chalk.white(`Service: ${chalk.bold(serviceName)}`));
+      console.log(chalk.white(`Type: ${serviceType}`));
+      console.log(chalk.white(`Path: ${servicePath}\n`));
+
+      // Step 2: Smart credential gathering
+      // Priority: flags → environment variables → fail with helpful message
+      const credentials = {
+        token: options.token || process.env.CLOUDFLARE_API_TOKEN,
+        accountId: options.accountId || process.env.CLOUDFLARE_ACCOUNT_ID,
+        zoneId: options.zoneId || process.env.CLOUDFLARE_ZONE_ID
+      };
+
+      // Check for missing credentials
+      const missing = [];
+      if (!credentials.token) missing.push('CLOUDFLARE_API_TOKEN');
+      if (!credentials.accountId) missing.push('CLOUDFLARE_ACCOUNT_ID');
+      if (!credentials.zoneId) missing.push('CLOUDFLARE_ZONE_ID');
+      if (missing.length > 0) {
+        console.error(chalk.red('❌ Missing required Cloudflare credentials\n'));
+        console.error(chalk.white('Please provide via:'));
+        console.error(chalk.cyan('  Environment Variables:'));
+        missing.forEach(key => {
+          console.error(chalk.white(`    export ${key}=<your-${key.toLowerCase()}>`));
+        });
+        console.error(chalk.cyan('\n  Command Flags:'));
+        if (missing.includes('CLOUDFLARE_API_TOKEN')) {
+          console.error(chalk.white('    --token <token>'));
+        }
+        if (missing.includes('CLOUDFLARE_ACCOUNT_ID')) {
+          console.error(chalk.white('    --account-id <id>'));
+        }
+        if (missing.includes('CLOUDFLARE_ZONE_ID')) {
+          console.error(chalk.white('    --zone-id <id>'));
+        }
+        console.error(chalk.cyan('\n  Example:'));
+        console.error(chalk.white('    npx clodo-service deploy --token abc123 --account-id xyz789 --zone-id def456'));
+        console.error(chalk.white('    OR'));
+        console.error(chalk.white('    export CLOUDFLARE_API_TOKEN=abc123'));
+        console.error(chalk.white('    export CLOUDFLARE_ACCOUNT_ID=xyz789'));
+        console.error(chalk.white('    export CLOUDFLARE_ZONE_ID=def456'));
+        console.error(chalk.white('    npx clodo-service deploy\n'));
+        process.exit(1);
+      }
+
+      // Step 3: Extract configuration from manifest
+      const config = manifest.configuration || {};
+      const domain = config.domain || config.domainName;
+      if (!domain) {
+        console.error(chalk.red('❌ No domain configured in service manifest'));
+        console.error(chalk.yellow('Update clodo-service-manifest.json with domain configuration'));
+        process.exit(1);
+      }
+      console.log(chalk.cyan('📋 Deployment Plan:'));
+      console.log(chalk.gray('─'.repeat(50)));
+      console.log(chalk.white(`Service:  ${serviceName}`));
+      console.log(chalk.white(`Type:     ${serviceType}`));
+      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)));
+      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;
+      try {
+        const module = await import('../../deployment/modular-enterprise-deploy.js');
+        ModularEnterpriseDeployer = module.ModularEnterpriseDeployer || module.default;
+      } catch (err) {
+        console.error(chalk.red('❌ Failed to load deployment system'));
+        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
+      });
+
+      // Run deployment
+      console.log(chalk.cyan('🚀 Starting deployment...\n'));
+      const result = await deployer.run({
+        manifest: manifest,
+        credentials: credentials,
+        dryRun: options.dryRun
+      });
+
+      // Display results
+      console.log(chalk.green('\n✅ Deployment Completed Successfully!\n'));
+      console.log(chalk.gray('─'.repeat(50)));
+      if (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}`));
+      if (result.workerId) {
+        console.log(chalk.white(`👤 Worker ID: ${result.workerId}`));
+      }
+      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.gray('─'.repeat(50)));
+
+      // 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'));
+      }
+      if (process.env.DEBUG && result.details) {
+        console.log(chalk.gray('\n📋 Full Result:'));
+        console.log(chalk.gray(JSON.stringify(result, null, 2)));
+      }
+    } catch (error) {
+      console.error(chalk.red(`\n❌ Deployment failed: ${error.message}`));
+      if (error.message.includes('credentials') || error.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 (error.message.includes('domain')) {
+        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(error.stack));
+      } else {
+        console.error(chalk.gray('Run with DEBUG=1 for full stack trace'));
+      }
+      process.exit(1);
+    }
+  });
+}

package/dist/bin/commands/diagnose.js

@@ -0,0 +1,70 @@
+/**
+ * Diagnose Command - Diagnose and report issues with an existing service
+ */
+
+import chalk from 'chalk';
+import { ServiceOrchestrator } from '../../src/service-management/ServiceOrchestrator.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) => {
+    try {
+      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'));
+          process.exit(1);
+        }
+      }
+      console.log(chalk.cyan('🔍 Diagnosing service...'));
+      const diagnosis = await orchestrator.diagnoseService(servicePath, options);
+
+      // Display results
+      console.log(chalk.cyan('\n📋 Diagnostic Report'));
+      console.log(chalk.white(`Service: ${diagnosis.serviceName || 'Unknown'}`));
+      console.log(chalk.white(`Path: ${servicePath}`));
+      if (diagnosis.errors.length > 0) {
+        console.log(chalk.red('\n❌ 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}`));
+          }
+        });
+      }
+      if (diagnosis.warnings.length > 0) {
+        console.log(chalk.yellow('\n⚠️  Warnings:'));
+        diagnosis.warnings.forEach(warning => {
+          console.log(chalk.yellow(`  • ${warning.message}`));
+          if (warning.suggestion) {
+            console.log(chalk.cyan(`    💡 ${warning.suggestion}`));
+          }
+        });
+      }
+      if (diagnosis.recommendations.length > 0) {
+        console.log(chalk.cyan('\n💡 Recommendations:'));
+        diagnosis.recommendations.forEach(rec => {
+          console.log(chalk.white(`  • ${rec}`));
+        });
+      }
+
+      // Export report if requested
+      if (options.exportReport) {
+        await orchestrator.exportDiagnosticReport(diagnosis, options.exportReport);
+        console.log(chalk.green(`\n📄 Report exported to: ${options.exportReport}`));
+      }
+
+      // Exit with error code if critical issues found
+      if (diagnosis.errors.length > 0) {
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error(chalk.red(`Diagnosis failed: ${error.message}`));
+      process.exit(1);
+    }
+  });
+}

package/dist/bin/commands/helpers.js

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

package/dist/bin/commands/update.js

@@ -0,0 +1,55 @@
+/**
+ * Update Command - Update an existing service configuration
+ */
+
+import chalk from 'chalk';
+import { ServiceOrchestrator } from '../../src/service-management/ServiceOrchestrator.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) => {
+    try {
+      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'));
+          process.exit(1);
+        }
+        console.log(chalk.cyan(`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}`));
+          });
+          process.exit(1);
+        }
+      }
+      if (options.interactive) {
+        await orchestrator.runInteractiveUpdate(servicePath);
+      } else {
+        await orchestrator.runNonInteractiveUpdate(servicePath, options);
+      }
+      console.log(chalk.green('\n✓ Service update completed successfully!'));
+    } catch (error) {
+      console.error(chalk.red(`\n✗ Service update failed: ${error.message}`));
+      if (error.details) {
+        console.error(chalk.yellow(`Details: ${error.details}`));
+      }
+      if (error.recovery) {
+        console.log(chalk.cyan('\n💡 Recovery suggestions:'));
+        error.recovery.forEach(suggestion => {
+          console.log(chalk.white(`  • ${suggestion}`));
+        });
+      }
+      process.exit(1);
+    }
+  });
+}