@tamyla/clodo-framework 3.1.24 → 3.1.26

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [3.1.26](https://github.com/tamylaa/clodo-framework/compare/v3.1.25...v3.1.26) (2025-12-02)
+
+
+### Bug Fixes
+
+* correct import paths for npm package distribution - use proper depth for compiled dist/ files ([d346563](https://github.com/tamylaa/clodo-framework/commit/d3465637e02077e014661e1039421e9cd0010d97))
+
+## [3.1.25](https://github.com/tamylaa/clodo-framework/compare/v3.1.24...v3.1.25) (2025-12-02)
+
+
+### Bug Fixes
+
+* correct all import paths and add prevention documentation ([dbd3ce6](https://github.com/tamylaa/clodo-framework/commit/dbd3ce6d6b3ceceb9aa839358923c6096c762ceb))
+
 ## [3.1.24](https://github.com/tamylaa/clodo-framework/compare/v3.1.23...v3.1.24) (2025-11-08)
 
 

package/dist/cli/clodo-simple.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+
+/**
+ * Simple CLI - Simplified interface for Clodo Framework
+ *
+ * A streamlined CLI that provides easy access to core framework functionality
+ * using the unified simple API with sensible defaults.
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { Clodo } from '../src/simple-api.js';
+
+// Create program instance
+const program = new Command();
+program.name('clodo').description('Simple CLI for Clodo Framework - streamlined service management').version('1.0.0');
+
+/**
+ * Create command - Simple service creation
+ */
+program.command('create <name>').description('Create a new service with minimal configuration').option('-t, --type <type>', 'Service type', 'generic').option('-d, --domain <domain>', 'Domain name', 'example.com').option('-e, --env <env>', 'Environment', 'development').option('-o, --output <path>', 'Output directory', '.').option('--token <token>', 'Cloudflare API token').option('--account-id <id>', 'Cloudflare account ID').option('--zone-id <id>', 'Cloudflare zone ID').action(async (name, options) => {
+  try {
+    console.log(chalk.cyan(`🚀 Creating service: ${name}`));
+    const result = await Clodo.createService({
+      name,
+      type: options.type,
+      domain: options.domain,
+      environment: options.env,
+      outputPath: options.output,
+      credentials: {
+        token: options.token,
+        accountId: options.accountId,
+        zoneId: options.zoneId
+      }
+    });
+    console.log(chalk.green(`✅ ${result.message}`));
+    console.log(chalk.white(`📁 Created in: ${result.outputPath}`));
+  } catch (error) {
+    console.error(chalk.red(`❌ ${error.message}`));
+    process.exit(1);
+  }
+});
+
+/**
+ * Deploy command - Simple service deployment
+ */
+program.command('deploy').description('Deploy a service with smart configuration detection').option('-p, --path <path>', 'Service directory path', '.').option('-e, --env <env>', 'Target environment', 'production').option('-d, --domain <domain>', 'Specific domain to deploy to').option('--dry-run', 'Simulate deployment without changes').option('--token <token>', 'Cloudflare API token').option('--account-id <id>', 'Cloudflare account ID').option('--zone-id <id>', 'Cloudflare zone ID').action(async options => {
+  try {
+    console.log(chalk.cyan(`🚀 Deploying service...`));
+    const result = await Clodo.deploy({
+      servicePath: options.path,
+      environment: options.env,
+      domain: options.domain,
+      dryRun: options.dryRun,
+      credentials: {
+        token: options.token,
+        accountId: options.accountId,
+        zoneId: options.zoneId
+      }
+    });
+    console.log(chalk.green(`✅ ${result.message}`));
+    if (result.deployedDomains) {
+      console.log(chalk.white(`🌐 Deployed to: ${result.deployedDomains.join(', ')}`));
+    }
+  } catch (error) {
+    console.error(chalk.red(`❌ ${error.message}`));
+    process.exit(1);
+  }
+});
+
+/**
+ * Validate command - Simple service validation
+ */
+program.command('validate').description('Validate a service configuration').option('-p, --path <path>', 'Service directory path', '.').option('-r, --report', 'Export validation report').action(async options => {
+  try {
+    console.log(chalk.cyan(`🔍 Validating service...`));
+    const result = await Clodo.validate({
+      servicePath: options.path,
+      exportReport: options.report
+    });
+    if (result.success) {
+      console.log(chalk.green(`✅ ${result.message}`));
+    } else {
+      console.log(chalk.yellow(`⚠️  ${result.message}`));
+      if (result.issues && result.issues.length > 0) {
+        console.log(chalk.white('Issues found:'));
+        result.issues.forEach((issue, index) => {
+          console.log(chalk.white(`  ${index + 1}. ${issue}`));
+        });
+      }
+    }
+  } catch (error) {
+    console.error(chalk.red(`❌ ${error.message}`));
+    process.exit(1);
+  }
+});
+
+/**
+ * Info command - Show framework information
+ */
+program.command('info').description('Show framework information').action(() => {
+  const info = Clodo.getInfo();
+  console.log(chalk.cyan(`${info.name} v${info.version}`));
+  console.log(chalk.white(info.description));
+  console.log(chalk.white('\nFeatures:'));
+  info.features.forEach(feature => {
+    console.log(chalk.white(`  • ${feature}`));
+  });
+});
+
+// Parse command line arguments
+program.parse();

package/dist/cli/commands/assess.js

@@ -5,16 +5,16 @@
 
 import chalk from 'chalk';
 import path from 'path';
-import { ServiceOrchestrator } from '../service-management/ServiceOrchestrator.js';
-import { StandardOptions } from '../lib/shared/utils/cli-options.js';
-import { ServiceConfigManager } from '../lib/shared/utils/service-config-manager.js';
+import { ServiceOrchestrator } from '../../src/service-management/ServiceOrchestrator.js';
+import { StandardOptions } from '../../lib/shared/utils/cli-options.js';
+import { ServiceConfigManager } from '../../lib/shared/utils/service-config-manager.js';
 export function registerAssessCommand(program) {
   const command = 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').option('--show-config-sources', 'Display all configuration sources and merged result');
 
   // Add standard options (--verbose, --quiet, --json, --no-color, --config-file)
   StandardOptions.define(command).action(async (servicePath, options) => {
     try {
-      const output = new (await import('../lib/shared/utils/output-formatter.js')).OutputFormatter(options);
+      const output = new (await import('../../lib/shared/utils/output-formatter.js')).OutputFormatter(options);
       const configManager = new ServiceConfigManager({
         verbose: options.verbose,
         quiet: options.quiet,
@@ -111,7 +111,7 @@ export function registerAssessCommand(program) {
         output.success(`📄 Results exported to: ${mergedOptions.export}`);
       }
     } catch (error) {
-      const output = new (await import('../lib/shared/utils/output-formatter.js')).OutputFormatter(options || {});
+      const output = new (await import('../../lib/shared/utils/output-formatter.js')).OutputFormatter(options || {});
       output.error(`Assessment failed: ${error.message}`);
       if (process.env.DEBUG) {
         output.debug(error.stack);

package/dist/cli/commands/create.js

@@ -6,16 +6,16 @@
  */
 
 import chalk from 'chalk';
-import { ServiceOrchestrator } from '../service-management/ServiceOrchestrator.js';
-import { StandardOptions } from '../lib/shared/utils/cli-options.js';
-import { ConfigLoader } from '../lib/shared/utils/config-loader.js';
+import { Clodo } from '../../src/simple-api.js';
+import { StandardOptions } from '../../lib/shared/utils/cli-options.js';
+import { ConfigLoader } from '../../lib/shared/utils/config-loader.js';
 export function registerCreateCommand(program) {
   const command = 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').option('--force', 'Skip confirmation prompts').option('--validate', 'Validate service after creation');
 
   // Add standard options (--verbose, --quiet, --json, --no-color, --config-file)
   StandardOptions.define(command).action(async options => {
     try {
-      const output = new (await import('../lib/shared/utils/output-formatter.js')).OutputFormatter(options);
+      const output = new (await import('../../lib/shared/utils/output-formatter.js')).OutputFormatter(options);
       const configLoader = new ConfigLoader({
         verbose: options.verbose,
         quiet: options.quiet,
@@ -33,40 +33,31 @@ export function registerCreateCommand(program) {
 
       // Merge config file defaults with CLI options (CLI takes precedence)
       const mergedOptions = configLoader.merge(configFileData, options);
-      const orchestrator = new ServiceOrchestrator({
-        interactive: !mergedOptions.nonInteractive,
+
+      // Use simple API for service creation
+      const result = await Clodo.createService({
+        name: mergedOptions.serviceName,
+        type: mergedOptions.serviceType,
+        domain: mergedOptions.domainName,
+        environment: mergedOptions.environment,
         outputPath: mergedOptions.outputPath,
-        templatePath: mergedOptions.templatePath
-      });
-      if (mergedOptions.nonInteractive) {
-        // Validate required parameters for non-interactive mode
-        const required = ['serviceName', 'domainName', 'cloudflareToken', 'cloudflareAccountId', 'cloudflareZoneId'];
-        const missing = required.filter(key => !mergedOptions[key]);
-        if (missing.length > 0) {
-          output.error(`Missing required parameters: ${missing.join(', ')}`);
-          output.info('Use --help for parameter details');
-          process.exit(1);
+        interactive: !mergedOptions.nonInteractive,
+        credentials: {
+          token: mergedOptions.cloudflareToken,
+          accountId: mergedOptions.cloudflareAccountId,
+          zoneId: mergedOptions.cloudflareZoneId
         }
-
-        // Convert merged options to core inputs
-        const coreInputs = {
-          serviceName: mergedOptions.serviceName,
-          serviceType: mergedOptions.serviceType,
-          domainName: mergedOptions.domainName,
-          cloudflareToken: mergedOptions.cloudflareToken,
-          cloudflareAccountId: mergedOptions.cloudflareAccountId,
-          cloudflareZoneId: mergedOptions.cloudflareZoneId,
-          environment: mergedOptions.environment
-        };
-        await orchestrator.runNonInteractive(coreInputs);
+      });
+      if (result.success) {
+        output.success(result.message);
       } else {
-        await orchestrator.runInteractive();
+        output.error('Service creation failed');
+        process.exit(1);
       }
-      output.success('Service creation completed successfully!');
       output.section('Next steps');
       output.list(['cd into your new service directory', 'Run npm install', 'Configure additional settings in src/config/domains.js', 'Run npm run deploy to deploy to Cloudflare']);
     } catch (error) {
-      const output = new (await import('../lib/shared/utils/output-formatter.js')).OutputFormatter(options || {});
+      const output = new (await import('../../lib/shared/utils/output-formatter.js')).OutputFormatter(options || {});
       output.error(`Service creation failed: ${error.message}`);
       if (error.details) {
         output.warning(`Details: ${error.details}`);

package/dist/cli/commands/deploy.js

@@ -1,42 +1,16 @@
-/**
- * Deploy Command - Smart minimal input deployment with service detection
- * 
- * 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
- * - REFACTORED (Task 3.2): Integrates with MultiDomainOrchestrator for full deployment orchestration
- * - REFACTORED (UX): Modularized with helper functions for better maintainability
- */
-
 import chalk from 'chalk';
-import { resolve, join } from 'path';
-import { existsSync } from 'fs';
-import { ManifestLoader } from '../lib/shared/config/manifest-loader.js';
-import { CloudflareServiceValidator } from '../lib/shared/config/cloudflare-service-validator.js';
-import { DeploymentCredentialCollector } from '../lib/shared/deployment/credential-collector.js';
-import { StandardOptions } from '../lib/shared/utils/cli-options.js';
-import { ConfigLoader } from '../lib/shared/utils/config-loader.js';
-import { ServiceConfigManager } from '../lib/shared/utils/service-config-manager.js';
-import { DomainRouter } from '../lib/shared/routing/domain-router.js';
-import { MultiDomainOrchestrator } from '../orchestration/multi-domain-orchestrator.js';
-
-// Import modular helpers
-import { detectExistingResources, displayDeploymentPlan } from './helpers/resource-detection.js';
-import { confirmDeployment, displayDeploymentResults, displayNextSteps } from './helpers/deployment-ui.js';
-import { runPostDeploymentVerification } from './helpers/deployment-verification.js';
-import { handleDeploymentError } from './helpers/error-recovery.js';
+import { Clodo } from '../../src/simple-api.js';
+import { StandardOptions } from '../../lib/shared/utils/cli-options.js';
+import { ConfigLoader } from '../../lib/shared/utils/config-loader.js';
 export function registerDeployCommand(program) {
   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('--development', 'Deploy to development environment (shorthand for --environment development)').option('--staging', 'Deploy to staging environment (shorthand for --environment staging)').option('--production', 'Deploy to production environment (shorthand for --environment production)').option('--all-domains', 'Deploy to all configured domains (ignores --domain flag)').option('--dry-run', 'Simulate deployment without making changes').option('-y, --yes', 'Skip confirmation prompts (for CI/CD)').option('--service-path <path>', 'Path to service directory', '.').option('--show-config-sources', 'Display all configuration sources and merged result');
+  .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('--development', 'Deploy to development environment (shorthand for --environment development)').option('--staging', 'Deploy to staging environment (shorthand for --environment staging)').option('--production', 'Deploy to production environment (shorthand for --environment production)').option('--dry-run', 'Simulate deployment without making changes').option('-y, --yes', 'Skip confirmation prompts (for CI/CD)').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 {
-      const output = new (await import('../lib/shared/utils/output-formatter.js')).OutputFormatter(options);
+      const output = new (await import('../../lib/shared/utils/output-formatter.js')).OutputFormatter(options);
       const configLoader = new ConfigLoader({
         verbose: options.verbose,
         quiet: options.quiet,
@@ -61,342 +35,33 @@ export function registerDeployCommand(program) {
         }
       }
 
-      // Use ServiceConfigManager for standardized config loading
-      const configManager = new ServiceConfigManager({
-        verbose: options.verbose,
-        quiet: options.quiet,
-        json: options.json,
-        showSources: options.showConfigSources
-      });
-
-      // For deploy command, we use current directory as service path
-      const deployServicePath = resolve(options.servicePath || '.');
-
-      // Load and merge all configurations
-      const mergedOptions = await configManager.loadServiceConfig(deployServicePath, {
-        ...options,
-        configFile: options.configFile // Pass through the config file option
-      }, {
-        token: null,
-        accountId: null,
-        zoneId: null,
-        domain: null,
-        environment: 'production',
-        allDomains: false,
-        dryRun: false,
-        yes: false,
-        servicePath: '.'
-      });
-      output.info('🚀 Clodo Service Deployment');
-
-      // Step 1: Load and validate service configuration
-      const servicePath = resolve(mergedOptions.servicePath || deployServicePath);
-      const serviceConfig = await ManifestLoader.loadAndValidateCloudflareService(servicePath);
-      if (!serviceConfig.manifest) {
-        if (serviceConfig.error === 'NOT_A_CLOUDFLARE_SERVICE') {
-          ManifestLoader.printNotCloudflareServiceError(servicePath);
-        } else if (serviceConfig.error === 'CLOUDFLARE_SERVICE_INVALID') {
-          // Pass false because we're validating a detected service, not a Clodo manifest
-          ManifestLoader.printValidationErrors(serviceConfig.validationResult, false);
-        }
-        process.exit(1);
-      }
-
-      // Print service info and validation results
-      if (serviceConfig.validationResult) {
-        CloudflareServiceValidator.printValidationReport(serviceConfig.validationResult.validation);
-      }
-      ManifestLoader.printManifestInfo(serviceConfig.manifest);
-      console.log(chalk.blue(`ℹ️  Configuration loaded from: ${serviceConfig.foundAt}`));
+      // Merge config file defaults with CLI options (CLI takes precedence)
+      const mergedOptions = configLoader.merge(configFileData, options);
 
-      // Step 2: Smart credential gathering with interactive collection
-      // Uses DeploymentCredentialCollector which:
-      // - Checks flags and env vars first
-      // - Prompts for API token if needed
-      // - Validates token and auto-fetches account ID & zone ID
-      // - Caches credentials for future use
-      const credentialCollector = new DeploymentCredentialCollector({
-        servicePath: servicePath,
-        quiet: mergedOptions.quiet
-      });
-      let credentials;
-      try {
-        credentials = await credentialCollector.collectCredentials({
+      // Use simple API for deployment
+      const result = await Clodo.deploy({
+        servicePath: mergedOptions.servicePath || '.',
+        environment: mergedOptions.environment || 'production',
+        domain: mergedOptions.domain,
+        dryRun: mergedOptions.dryRun || false,
+        credentials: {
           token: mergedOptions.token,
           accountId: mergedOptions.accountId,
           zoneId: mergedOptions.zoneId
-        });
-      } finally {
-        credentialCollector.cleanup();
-      }
-
-      // 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 manifest but we have a selected zone from credentials, use that
-      if (detectedDomains.length === 0 && credentials.zoneName) {
-        detectedDomains = [credentials.zoneName];
-        if (!options.quiet) {
-          console.log(chalk.blue(`ℹ️  Using selected Cloudflare domain: ${credentials.zoneName}`));
-        }
-      }
-
-      // If still no domains and it's a detected CF service, use default
-      if (detectedDomains.length === 0 && manifest._source === 'cloudflare-service-detected') {
-        // For detected CF services, use default
-        detectedDomains = ['workers.cloudflare.com'];
-        if (!options.quiet) {
-          console.log(chalk.blue(`ℹ️  No custom domains configured, using default: workers.cloudflare.com`));
-        }
-      } else if (detectedDomains.length > 0 && !options.quiet && !credentials.zoneName) {
-        console.log(chalk.blue(`ℹ️  Found ${detectedDomains.length} configured domain(s) in manifest`));
-      }
-
-      // Domain selection: check CLI flag first, then prompt user
-      let selectedDomain = mergedOptions.domain;
-      if (selectedDomain && !options.quiet) {
-        console.log(chalk.blue(`ℹ️  Using domain from --domain flag: ${selectedDomain}`));
-      }
-      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(`✓ Auto-selected only available 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';
-
-      // Step 5: Detect existing resources and display deployment plan
-      const {
-        existingWorker,
-        existingDatabases,
-        resourceDetectionFailed
-      } = await detectExistingResources(serviceName, manifest, credentials, output, options.verbose);
-      displayDeploymentPlan({
-        serviceName,
-        serviceType,
-        selectedDomain,
-        environment: mergedOptions.environment,
-        credentials,
-        dryRun: options.dryRun,
-        existingWorker,
-        existingDatabases,
-        resourceDetectionFailed,
-        manifest
       });
-
-      // Step 6: Get user confirmation
-      const confirmed = await confirmDeployment(options);
-      if (!confirmed) {
-        process.exit(0);
-      }
-
-      // 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'));
-
-      // Determine wrangler config path based on selected domain/zone
-      // For multi-customer deployments, use customer-specific config if available
-      let wranglerConfigPath;
-      const configDir = join(servicePath, 'config');
-
-      // Map domain to config file (customize this mapping for your setup)
-      if (selectedDomain === 'clodo.dev' || credentials.cloudflareSettings?.zoneName === 'clodo.dev') {
-        // Use config/wrangler.toml for clodo.dev domain
-        const clodoConfigPath = join(configDir, 'wrangler.toml');
-        if (existsSync(clodoConfigPath)) {
-          wranglerConfigPath = clodoConfigPath;
-          console.log(chalk.green(`✓ Using clodo.dev config: ${clodoConfigPath}`));
-        }
-      }
-      // Add more domain mappings as needed:
-      // else if (selectedDomain === 'customer2.com') {
-      //   wranglerConfigPath = path.join(configDir, 'customers', 'customer2-wrangler.toml');
-      // }
-
-      // If no specific config found, use default (root wrangler.toml)
-      if (!wranglerConfigPath) {
-        console.log(chalk.yellow(`ℹ Using default wrangler.toml from service root`));
-      }
-      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,
-        serviceName: serviceName,
-        // Pass service name for custom domain construction
-        wranglerConfigPath: wranglerConfigPath,
-        // Pass custom config path if found
-        // Use cloudflareSettings object for complete zone-specific configuration
-        cloudflareSettings: credentials.cloudflareSettings,
-        enablePersistence: !options.dryRun,
-        rollbackEnabled: !options.dryRun,
-        verbose: options.verbose
-      });
-      try {
-        await orchestrator.initialize();
-      } catch (err) {
-        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));
+      if (result.success) {
+        output.success(result.message);
+        if (result.deployedDomains && result.deployedDomains.length > 0) {
+          output.info(`Deployed to domains: ${result.deployedDomains.join(', ')}`);
         }
+      } else {
+        output.error('Deployment failed');
         process.exit(1);
       }
-
-      // Step 7: 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) {
-        await handleDeploymentError(deployError, command, options);
-      }
-
-      // Step 8: Display deployment results
-      displayDeploymentResults({
-        result,
-        serviceName,
-        serviceType,
-        selectedDomain,
-        environment: mergedOptions.environment
-      });
-
-      // Step 9: Run post-deployment verification and health check
-      await runPostDeploymentVerification(serviceName, result, credentials, {
-        ...options,
-        serviceName,
-        customDomain: selectedDomain !== 'workers.cloudflare.com' ? selectedDomain : null
-      });
-
-      // Step 10: Display next steps
-      displayNextSteps({
-        result,
-        selectedDomain,
-        serviceName,
-        dryRun: options.dryRun
-      });
-      if (process.env.DEBUG && result.details) {
-        console.log(chalk.gray('📋 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') || 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));
-      } else {
-        console.error(chalk.gray('Run with DEBUG=1 for full stack trace'));
-      }
+      const output = new (await import('../../lib/shared/utils/output-formatter.js')).OutputFormatter(options || {});
+      output.error(`Deployment failed: ${error.message}`);
       process.exit(1);
     }
   });