@tamyla/clodo-framework 3.1.21 → 3.1.22

package/CHANGELOG.md

@@ -1,3 +1,12 @@
+## [3.1.22](https://github.com/tamylaa/clodo-framework/compare/v3.1.21...v3.1.22) (2025-11-05)
+
+
+### Bug Fixes
+
+* clarify bin/ is private CLI implementation, not public API ([a092d30](https://github.com/tamylaa/clodo-framework/commit/a092d30c9c9c72f0bcb9d6b132175b4a6d6ce0bf))
+* Separate clodo-enterprise: remove enterprise code/docs, fix imports, update README ([58aabff](https://github.com/tamylaa/clodo-framework/commit/58aabff0b0fa193cd2acf37027e43a872fccd8f2))
+* wire helpers to shared infra and fix CloudflareAPI import casing ([7d0b27f](https://github.com/tamylaa/clodo-framework/commit/7d0b27f8dbd0a82f01d52a4d00324ab72507ab30))
+
 ## [3.1.21](https://github.com/tamylaa/clodo-framework/compare/v3.1.20...v3.1.21) (2025-10-28)
 
 

package/README.md

@@ -8,6 +8,59 @@ A comprehensive framework for building enterprise-grade software architecture on
 
 Just like Clodo bricks snap together to build anything you can imagine, this framework provides the base components that your services snap into. Focus on your business logic while the framework handles the infrastructure, configuration, and deployment patterns.
 
+## Two Ways to Use Clodo Framework
+
+### 📦 As a Library (Public API)
+
+Import framework modules into your project for programmatic use:
+
+```javascript
+// Import core services
+import { GenericDataService } from '@tamyla/clodo-framework/services';
+import { EnhancedRouter } from '@tamyla/clodo-framework/routing';
+import { CloudflareAPI } from '@tamyla/clodo-framework/utils/cloudflare';
+import { DeploymentOrchestrator } from '@tamyla/clodo-framework/deployment';
+
+// Use framework utilities
+const api = new CloudflareAPI(token);
+const zones = await api.listZones();
+```
+
+**All public exports are defined in `package.json`** - use only these documented paths.
+
+### 🔧 As CLI Tools (Commands)
+
+Run framework commands in your terminal:
+
+```bash
+# Deploy your service
+clodo-service deploy
+
+# Create a new service
+clodo-create-service my-service
+
+# Security auditing
+clodo-security audit
+```
+
+**CLI tools are for terminal use only** - they use interactive prompts, colored output, and are not meant for programmatic import.
+
+### ⚠️ Important: Don't Import from `dist/bin/`
+
+The `bin/` directory contains CLI implementation details and should **never** be imported directly:
+
+```javascript
+// ❌ WRONG - Don't do this
+import { healthCheckWithBackoff } from '@tamyla/clodo-framework/dist/bin/shared/monitoring/health-checker.js';
+import { deploymentUI } from '@tamyla/clodo-framework/dist/bin/commands/helpers/deployment-ui.js';
+
+// ✅ CORRECT - Use public API
+import { DeploymentOrchestrator } from '@tamyla/clodo-framework/deployment';
+import { CloudflareAPI } from '@tamyla/clodo-framework/utils/cloudflare';
+```
+
+If you need functionality that's currently only in `bin/`, please open an issue - we'll consider adding it to the public API.
+
 ## Project Structure
 
 The project is organized for maximum clarity and maintainability:

package/dist/bin/clodo-service.js

@@ -18,25 +18,54 @@
 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);
+// Dynamically load available command modules
+// This makes the CLI resilient if some commands are excluded from the package
+async function registerAvailableCommands() {
+  const commands = [{
+    name: 'create',
+    path: './commands/create.js',
+    register: 'registerCreateCommand'
+  }, {
+    name: 'deploy',
+    path: './commands/deploy.js',
+    register: 'registerDeployCommand'
+  }, {
+    name: 'validate',
+    path: './commands/validate.js',
+    register: 'registerValidateCommand'
+  }, {
+    name: 'update',
+    path: './commands/update.js',
+    register: 'registerUpdateCommand'
+  }, {
+    name: 'diagnose',
+    path: './commands/diagnose.js',
+    register: 'registerDiagnoseCommand'
+  }, {
+    name: 'assess',
+    path: './commands/assess.js',
+    register: 'registerAssessCommand'
+  }, {
+    name: 'init-config',
+    path: './commands/init-config.js',
+    register: 'registerInitConfigCommand'
+  }];
+  for (const cmd of commands) {
+    try {
+      const module = await import(cmd.path);
+      if (module[cmd.register]) {
+        module[cmd.register](program);
+      }
+    } catch (error) {
+      // Command module not available in this package - skip silently
+      // This allows for minimal CLI distributions
+    }
+  }
+}
 
 // List available service types
 program.command('list-types').description('List available service types and their features').action(() => {
@@ -58,5 +87,8 @@ program.command('list-types').description('List available service types and thei
   });
 });
 
+// Register available commands dynamically
+await registerAvailableCommands();
+
 // Parse command line arguments
 program.parse();

package/dist/bin/commands/deploy.js

@@ -8,21 +8,29 @@
  * - 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 } from 'path';
+import { resolve, join } from 'path';
+import { existsSync } from 'fs';
 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";
+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';
 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('--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', '.');
+  .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', '.');
 
   // Add standard options (--verbose, --quiet, --json, --no-color, --config-file)
   StandardOptions.define(command).action(async options => {
@@ -34,6 +42,15 @@ export function registerDeployCommand(program) {
         json: options.json
       });
 
+      // Handle shorthand environment flags
+      if (options.development) {
+        options.environment = 'development';
+      } else if (options.staging) {
+        options.environment = 'staging';
+      } else if (options.production) {
+        options.environment = 'production';
+      }
+
       // Load config from file if specified
       let configFileData = {};
       if (options.configFile) {
@@ -68,7 +85,7 @@ export function registerDeployCommand(program) {
         CloudflareServiceValidator.printValidationReport(serviceConfig.validationResult.validation);
       }
       ManifestLoader.printManifestInfo(serviceConfig.manifest);
-      output.info(`Configuration loaded from: ${serviceConfig.foundAt}`);
+      console.log(chalk.blue(`ℹ️  Configuration loaded from: ${serviceConfig.foundAt}`));
 
       // Step 2: Smart credential gathering with interactive collection
       // Uses DeploymentCredentialCollector which:
@@ -121,20 +138,36 @@ export function registerDeployCommand(program) {
         }).filter(d => d !== null);
       }
 
-      // If no domains in config, try to detect from environment
+      // 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(`✓ Selected domain: ${selectedDomain}`));
+            console.log(chalk.green(`✓ Auto-selected only available domain: ${selectedDomain}`));
           }
         } else {
           // Multiple domains available - let user choose
@@ -197,24 +230,58 @@ export function registerDeployCommand(program) {
       const serviceName = manifest.serviceName || 'unknown-service';
       const serviceType = manifest.serviceType || 'generic';
 
-      // 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 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',
@@ -223,8 +290,12 @@ export function registerDeployCommand(program) {
         parallelDeployments: 1,
         // Single domain in this flow
         servicePath: servicePath,
-        cloudflareToken: credentials.token,
-        cloudflareAccountId: credentials.accountId,
+        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
@@ -240,7 +311,7 @@ export function registerDeployCommand(program) {
         process.exit(1);
       }
 
-      // Step 6: Execute deployment via orchestrator
+      // Step 7: Execute deployment via orchestrator
       console.log(chalk.cyan('🚀 Starting deployment via orchestrator...\n'));
       let result;
       try {
@@ -251,71 +322,32 @@ export function registerDeployCommand(program) {
           environment: mergedOptions.environment || 'production'
         });
       } catch (deployError) {
-        console.error(chalk.red('\n❌ Deployment failed during orchestration\n'));
-        console.error(chalk.yellow(`Error: ${deployError.message}`));
-
-        // 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);
+        await handleDeploymentError(deployError, command, options);
       }
 
-      // Step 7: Display deployment results
-      console.log(chalk.green('\n✅ Deployment Completed Successfully!\n'));
-      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:         ${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}`));
-      }
-      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)}`));
-      }
+      // Step 8: Display deployment results
+      displayDeploymentResults({
+        result,
+        serviceName,
+        serviceType,
+        selectedDomain,
+        environment: mergedOptions.environment
+      });
 
-      // 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(60)));
+      // Step 9: Run post-deployment verification and health check
+      await runPostDeploymentVerification(serviceName, result, credentials, {
+        ...options,
+        serviceName,
+        customDomain: selectedDomain !== 'workers.cloudflare.com' ? selectedDomain : null
+      });
 
-      // Display next steps
-      if (!options.dryRun) {
-        console.log(chalk.cyan('\n💡 Next Steps:'));
-        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`));
-      }
+      // 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)));

package/dist/bin/commands/helpers/deployment-ui.js

@@ -0,0 +1,138 @@
+/**
+ * Deployment UI Helpers
+ * Handles confirmation prompts and next steps display
+ */
+
+import chalk from 'chalk';
+
+/**
+ * Prompt user for deployment confirmation
+ * @param {Object} options - CLI options
+ * @returns {Promise<boolean>} Whether user confirmed
+ */
+export async function confirmDeployment(options) {
+  // Skip confirmation if: --yes flag, --dry-run mode, or non-interactive terminal
+  if (options.dryRun) {
+    return true; // Dry run doesn't need confirmation
+  }
+  if (options.yes) {
+    console.log(chalk.gray('\n⚡ Auto-confirming deployment (--yes flag)\n'));
+    return true;
+  }
+  if (!process.stdin.isTTY) {
+    console.log(chalk.yellow('\n⚠️  Non-interactive mode: proceeding without confirmation'));
+    console.log(chalk.gray('💡 Tip: Use --yes to suppress this warning\n'));
+    return true;
+  }
+
+  // Interactive confirmation
+  console.log(''); // Blank line for spacing
+
+  const {
+    createPromptModule
+  } = await import('inquirer');
+  const prompt = createPromptModule();
+  const {
+    confirmed
+  } = await prompt([{
+    type: 'confirm',
+    name: 'confirmed',
+    message: chalk.bold('Proceed with this deployment?'),
+    default: false
+  }]);
+  if (!confirmed) {
+    console.log(chalk.yellow('\n❌ Deployment cancelled by user\n'));
+    console.log(chalk.gray('💡 Tip: Use --dry-run to preview changes without deploying'));
+    return false;
+  }
+  console.log(''); // Blank line before starting deployment
+  return true;
+}
+
+/**
+ * Display deployment results summary
+ * @param {Object} resultData - Deployment result data
+ */
+export function displayDeploymentResults(resultData) {
+  const {
+    result,
+    serviceName,
+    serviceType,
+    selectedDomain,
+    environment
+  } = resultData;
+  console.log(chalk.green('\n✅ Deployment Completed Successfully!\n'));
+  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:         ${serviceName}`));
+  console.log(chalk.white(`🔧 Type:            ${serviceType}`));
+  console.log(chalk.white(`🌍 Domain:          ${selectedDomain}`));
+  console.log(chalk.white(`🌎 Environment:     ${environment || 'production'}`));
+  if (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)}`));
+  }
+
+  // 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(60)));
+}
+
+/**
+ * Display next steps after deployment
+ * @param {Object} stepsData - Next steps data
+ */
+export function displayNextSteps(stepsData) {
+  const {
+    result,
+    selectedDomain,
+    serviceName,
+    dryRun
+  } = stepsData;
+  if (dryRun) {
+    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`));
+    return;
+  }
+  console.log(chalk.cyan('\n💡 Next Steps:\n'));
+
+  // Show both URLs if worker deployed
+  if (result.url) {
+    console.log(chalk.white(`  🌐 Your service is live at:`));
+    console.log(chalk.green(`     ${result.url}`));
+
+    // Show custom domain if different from workers.dev
+    if (selectedDomain !== 'workers.cloudflare.com' && !selectedDomain.includes('workers.dev')) {
+      console.log(chalk.white(`\n  ⚠️  Custom domain requires DNS setup:`));
+      console.log(chalk.yellow(`     Domain: ${selectedDomain}`));
+      console.log(chalk.gray(`     Add CNAME record: ${selectedDomain} → workers.dev`));
+      console.log(chalk.gray(`     Or add route in Cloudflare Dashboard`));
+    }
+  }
+  console.log(chalk.white(`\n  📝 Testing:`));
+  console.log(chalk.gray(`     curl ${result.url || `https://${selectedDomain}`}/health`));
+  console.log(chalk.white(`\n  📊 Monitoring:`));
+  console.log(chalk.gray(`     wrangler tail ${serviceName}`));
+  console.log(chalk.gray(`     https://dash.cloudflare.com`));
+  if (result.deploymentId) {
+    console.log(chalk.white(`\n  🔄 Rollback (if needed):`));
+    console.log(chalk.gray(`     clodo-service rollback ${result.deploymentId}`));
+  }
+  console.log(''); // Blank line at end
+}