@tamyla/clodo-framework 3.1.21 → 3.1.23

package/dist/cli/commands/helpers/deployment-verification.js

@@ -0,0 +1,250 @@
+/**
+ * Deployment Verification Helpers (UI Wrapper)
+ * Provides UI-specific deployment verification by delegating to shared infrastructure
+ */
+
+import { verifyWorkerDeployment, healthCheckWithBackoff, checkHealth } from '../../lib/shared/monitoring/health-checker.js';
+import chalk from 'chalk';
+import readline from 'readline';
+
+/**
+ * Run comprehensive post-deployment verification
+ * @param {string} serviceName - Name of the service
+ * @param {Object} deploymentResult - Result from deployment
+ * @param {Object} credentials - Cloudflare credentials
+ * @param {Object} options - Verification options
+ * @returns {Promise<Object>} Verification result
+ */
+export async function runPostDeploymentVerification(serviceName, deploymentResult, credentials, options = {}) {
+  console.log('\n🔍 Post-deployment Verification');
+
+  // Skip health checks in dry-run mode with clear explanation
+  if (options.dryRun) {
+    console.log(chalk.blue('   ℹ️  Health checks skipped in dry-run mode'));
+    console.log(chalk.gray('   💡 Run without --dry-run to deploy and verify the worker'));
+    return {
+      success: true,
+      healthCheckPassed: null,
+      reason: 'dry-run-skipped'
+    };
+  }
+  try {
+    // Wait for deployment to propagate
+    console.log('   ⏳ Waiting for deployment to propagate...');
+    await new Promise(resolve => setTimeout(resolve, 5000));
+
+    // Run health checks with enhanced URL discovery
+    console.log('   🏥 Running health checks...');
+
+    // Try multiple sources for worker URL (in priority order)
+    const workerUrl = await discoverWorkerUrl(deploymentResult, credentials, options);
+    if (workerUrl) {
+      console.log(chalk.gray(`   🔗 Testing: ${workerUrl}`));
+      const health = await checkHealth(workerUrl).catch(err => {
+        console.log(chalk.yellow(`   ⚠️  Health check failed: ${err.message}`));
+        return {
+          status: 'unknown',
+          error: err.message
+        };
+      });
+      if (health && health.status === 'ok') {
+        console.log(`   ✅ Deployment verified: ${health.framework?.models?.length || 0} models active`);
+        return {
+          success: true,
+          healthCheckPassed: true,
+          healthData: health,
+          url: workerUrl
+        };
+      } else {
+        console.log(`   ⚠️ Health check returned: ${health?.status || 'unknown'}`);
+        if (health.error) {
+          console.log(chalk.gray(`   Error: ${health.error}`));
+        }
+        // Don't fail deployment for health check issues
+        return {
+          success: true,
+          healthCheckPassed: false,
+          healthData: health,
+          url: workerUrl
+        };
+      }
+    } else {
+      console.log(chalk.yellow('   ⚠️  No worker URL could be determined'));
+      console.log(chalk.gray('   💡 To fix: Add route in wrangler.toml or check Cloudflare dashboard'));
+      return {
+        success: true,
+        healthCheckPassed: null,
+        reason: 'no-url-discovered'
+      };
+    }
+  } catch (error) {
+    console.log(chalk.yellow(`   ⚠️  Post-deployment verification warning: ${error.message}`));
+    // Don't fail overall deployment for verification issues
+    return {
+      success: true,
+      healthCheckPassed: false,
+      error: error.message
+    };
+  }
+}
+
+/**
+ * Discover worker URL from multiple sources
+ * Priority: deploymentResult.url > workers.dev convention > Cloudflare API discovery
+ * @param {Object} deploymentResult - Result from deployment
+ * @param {Object} credentials - Cloudflare credentials
+ * @param {Object} options - Discovery options
+ * @returns {Promise<string|null>} Discovered worker URL or null
+ */
+async function discoverWorkerUrl(deploymentResult, credentials, options = {}) {
+  // Source 1: Direct URL from deployment result
+  if (deploymentResult?.url) {
+    return deploymentResult.url;
+  }
+
+  // Source 2: Construct workers.dev URL from credentials
+  if (credentials?.cloudflareSettings?.accountId && options.serviceName) {
+    const accountHash = credentials.cloudflareSettings.accountId;
+    const scriptName = options.serviceName || 'my-worker';
+    const workersDevUrl = `https://${scriptName}.${accountHash}.workers.dev`;
+
+    // Verify this URL exists by checking if we can reach it
+    const urlExists = await verifyUrlExists(workersDevUrl);
+    if (urlExists) {
+      return workersDevUrl;
+    }
+  }
+
+  // Source 3: Query Cloudflare API for worker routes
+  if (credentials?.cloudflareSettings) {
+    const discoveredUrl = await discoverUrlFromCloudflare(credentials.cloudflareSettings, options);
+    if (discoveredUrl) {
+      return discoveredUrl;
+    }
+  }
+
+  // Source 4: Custom domain from options
+  if (options.customDomain) {
+    return `https://${options.customDomain}`;
+  }
+  return null;
+}
+
+/**
+ * Verify if a URL exists (can be reached)
+ * @param {string} url - URL to verify
+ * @returns {Promise<boolean>} True if URL responds
+ */
+async function verifyUrlExists(url) {
+  try {
+    const response = await fetch(url, {
+      method: 'HEAD',
+      signal: AbortSignal.timeout(5000)
+    });
+    return response.ok || response.status === 404; // 404 means route exists but no handler
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Discover worker URL from Cloudflare API
+ * @param {Object} cloudflareSettings - Cloudflare credentials
+ * @param {Object} options - Discovery options
+ * @returns {Promise<string|null>} Discovered URL or null
+ */
+async function discoverUrlFromCloudflare(cloudflareSettings, options = {}) {
+  try {
+    const {
+      CloudflareAPI
+    } = await import('../../utils/cloudflare/api.js');
+    const api = new CloudflareAPI(cloudflareSettings.token);
+
+    // Get worker routes for the zone
+    if (cloudflareSettings.zoneId) {
+      const response = await api.request(`/zones/${cloudflareSettings.zoneId}/workers/routes`);
+      const routes = response.result || [];
+      if (routes.length > 0) {
+        // Find route for this worker
+        const scriptName = options.serviceName || options.workerName;
+        const matchingRoute = routes.find(r => r.script && (r.script === scriptName || r.script.includes(scriptName)));
+        if (matchingRoute && matchingRoute.pattern) {
+          // Convert route pattern to URL (basic conversion)
+          const url = matchingRoute.pattern.replace('*', '').replace('//', '//');
+          return url.startsWith('http') ? url : `https://${url}`;
+        }
+      }
+    }
+
+    // Fallback: Get worker info from scripts API
+    const scriptsResponse = await api.request(`/accounts/${cloudflareSettings.accountId}/workers/scripts`);
+    const scripts = scriptsResponse.result || [];
+    const scriptName = options.serviceName || options.workerName;
+    const script = scripts.find(s => s.id === scriptName || s.id.includes(scriptName));
+    if (script && script.url) {
+      return script.url;
+    }
+  } catch (error) {
+    // API discovery failed - not critical
+    if (options.verbose) {
+      console.log(chalk.gray(`   Could not discover URL from Cloudflare API: ${error.message}`));
+    }
+  }
+  return null;
+}
+
+/**
+ * Verify deployment via Cloudflare API (UI wrapper)
+ * @param {string} workerName - Name of the worker to verify
+ * @param {Object} credentials - Cloudflare credentials
+ * @param {Object} options - Verification options
+ * @returns {Promise<Object>} Verification result
+ */
+export async function verifyDeployment(workerName, credentials, options = {}) {
+  // Delegate to shared infrastructure
+  return await verifyWorkerDeployment(workerName, credentials, options);
+}
+
+/**
+ * Perform health check with user permission prompt
+ * @param {string} baseUrl - Base URL to check
+ * @param {Object} options - Health check options
+ * @returns {Promise<Object>} Health check result
+ */
+export async function performHealthCheckWithPermission(baseUrl, options = {}) {
+  const {
+    skipPrompt = false,
+    ...healthOptions
+  } = options;
+  if (!skipPrompt) {
+    const permission = await promptForHealthCheck();
+    if (!permission) {
+      console.log(chalk.yellow('\n⏭️  Health check skipped by user'));
+      return {
+        healthy: null,
+        skipped: true
+      };
+    }
+  }
+  console.log(chalk.gray('\n🏥 Running health checks with exponential backoff...\n'));
+
+  // Delegate to shared infrastructure
+  return await healthCheckWithBackoff(baseUrl, healthOptions);
+}
+
+/**
+ * Prompt user for health check permission
+ * @returns {Promise<boolean>} Whether to proceed with health check
+ */
+async function promptForHealthCheck() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise(resolve => {
+    rl.question(chalk.cyan('\n❓ Run health checks to verify deployment? (Y/n): '), answer => {
+      rl.close();
+      resolve(!answer || answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+    });
+  });
+}

package/dist/cli/commands/helpers/error-recovery.js

@@ -0,0 +1,80 @@
+/**
+ * Error Recovery Helpers (UI Wrapper)
+ * Provides interactive error recovery by delegating to shared error classification
+ */
+
+import { classifyError, getRecoverySuggestions } from '../../lib/shared/error-handling/error-classifier.js';
+import chalk from 'chalk';
+import readline from 'readline';
+
+/**
+ * Handle deployment error with contextual recovery options
+ * @param {Error} error - The deployment error
+ * @param {Object} context - Deployment context
+ * @returns {Promise<string>} Recovery action: 'retry', 'dry-run', or 'abort'
+ */
+export async function handleDeploymentError(error, context = {}) {
+  // Classify error using shared infrastructure
+  const errorType = classifyError(error);
+  const suggestions = getRecoverySuggestions(errorType);
+
+  // Display error with contextual information
+  console.error(chalk.red(`\n❌ Deployment failed: ${error.message}\n`));
+  console.log(chalk.yellow(`Error Type: ${errorType.toUpperCase()}\n`));
+
+  // Display recovery suggestions
+  console.log(chalk.cyan('💡 Suggestions:'));
+  suggestions.forEach(suggestion => {
+    console.log(chalk.gray(`   • ${suggestion}`));
+  });
+
+  // Prompt for recovery action
+  return await promptForRecoveryAction();
+}
+
+/**
+ * Prompt user for recovery action
+ * @returns {Promise<string>} Recovery action
+ */
+async function promptForRecoveryAction() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  console.log(chalk.cyan('\nRecovery Options:'));
+  console.log(chalk.gray('  1) Retry deployment'));
+  console.log(chalk.gray('  2) Run in dry-run mode to diagnose'));
+  console.log(chalk.gray('  3) Abort'));
+  return new Promise(resolve => {
+    rl.question(chalk.cyan('\nSelect option (1-3): '), answer => {
+      rl.close();
+      switch (answer.trim()) {
+        case '1':
+          resolve('retry');
+          break;
+        case '2':
+          resolve('dry-run');
+          break;
+        case '3':
+        default:
+          resolve('abort');
+          break;
+      }
+    });
+  });
+}
+
+/**
+ * Display error summary for non-interactive mode
+ * @param {Error} error - The error
+ */
+export function displayErrorSummary(error) {
+  const errorType = classifyError(error);
+  const suggestions = getRecoverySuggestions(errorType);
+  console.error(chalk.red(`\n❌ ${error.message}`));
+  console.log(chalk.yellow(`\nError Type: ${errorType.toUpperCase()}`));
+  console.log(chalk.cyan('\nSuggestions:'));
+  suggestions.forEach(suggestion => {
+    console.log(chalk.gray(`  • ${suggestion}`));
+  });
+}

package/dist/cli/commands/helpers/resource-detection.js

@@ -0,0 +1,113 @@
+/**
+ * Resource Detection Helpers
+ * Detects existing Cloudflare resources (workers, databases) for change tracking
+ */
+
+import chalk from 'chalk';
+
+/**
+ * Detect existing resources to show what will change
+ * @param {string} serviceName - Name of the service
+ * @param {Object} manifest - Service manifest
+ * @param {Object} credentials - Cloudflare credentials
+ * @param {Object} output - Output formatter
+ * @param {boolean} verbose - Verbose logging flag
+ * @returns {Promise<Object>} Detected resources
+ */
+export async function detectExistingResources(serviceName, manifest, credentials, output, verbose = false) {
+  let existingWorker = null;
+  let existingDatabases = [];
+  let resourceDetectionFailed = false;
+  try {
+    // Import CloudflareAPI to check existing resources
+    const {
+      CloudflareAPI
+    } = await import('../../utils/cloudflare/api.js');
+    const cfApi = new CloudflareAPI(credentials.token);
+
+    // Check if worker already exists
+    const workers = await cfApi.listWorkers(credentials.accountId);
+    existingWorker = workers.find(w => w.name === serviceName);
+
+    // Check existing databases
+    existingDatabases = await cfApi.listD1Databases(credentials.accountId);
+  } catch (error) {
+    resourceDetectionFailed = true;
+    if (verbose && output) {
+      output.warn(`Could not detect existing resources: ${error.message}`);
+    }
+  }
+  return {
+    existingWorker,
+    existingDatabases,
+    resourceDetectionFailed
+  };
+}
+
+/**
+ * Display deployment plan with change detection badges
+ * @param {Object} planData - Deployment plan data
+ */
+export function displayDeploymentPlan(planData) {
+  const {
+    serviceName,
+    serviceType,
+    selectedDomain,
+    environment,
+    credentials,
+    dryRun,
+    existingWorker,
+    existingDatabases,
+    resourceDetectionFailed,
+    manifest
+  } = planData;
+  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:     ${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: ${dryRun ? 'DRY RUN' : 'LIVE'}`));
+  console.log(chalk.gray('─'.repeat(60)));
+
+  // Show what will be deployed with change badges
+  console.log(chalk.cyan('\n📦 Resources:'));
+
+  // Worker status
+  if (existingWorker) {
+    const lastModified = existingWorker.modifiedOn ? new Date(existingWorker.modifiedOn).toLocaleString() : 'unknown';
+    console.log(chalk.yellow(`  [CHANGE] Worker: ${serviceName}`));
+    console.log(chalk.gray(`           Last deployed: ${lastModified}`));
+  } else if (!resourceDetectionFailed) {
+    console.log(chalk.green(`  [NEW]    Worker: ${serviceName}`));
+  } else {
+    console.log(chalk.white(`  [DEPLOY] Worker: ${serviceName}`));
+  }
+
+  // Database status (if manifest has database config)
+  if (manifest.database && manifest.database.name) {
+    const dbName = manifest.database.name;
+    const existingDb = existingDatabases.find(db => db.name === dbName || db.name === `${serviceName}-${dbName}`);
+    if (existingDb) {
+      console.log(chalk.yellow(`  [CHANGE] Database: ${dbName} (binding update)`));
+    } else if (!resourceDetectionFailed) {
+      console.log(chalk.green(`  [NEW]    Database: ${dbName}`));
+    } else {
+      console.log(chalk.white(`  [DEPLOY] Database: ${dbName}`));
+    }
+  }
+
+  // Routes
+  const workersDomain = `${serviceName}.${credentials.accountId}.workers.dev`;
+  console.log(chalk.green(`  [NEW]    Route: https://${workersDomain}`));
+  if (selectedDomain && selectedDomain !== 'workers.cloudflare.com') {
+    console.log(chalk.yellow(`  [MANUAL] Custom domain: ${selectedDomain}`));
+    console.log(chalk.gray(`           ⚠️  Requires DNS configuration (see post-deployment steps)`));
+  }
+  console.log(chalk.gray('─'.repeat(60)));
+  if (dryRun) {
+    console.log(chalk.yellow('\n🔍 DRY RUN MODE - No changes will be made\n'));
+  }
+}

package/dist/{bin → cli}/commands/helpers.js

@@ -6,34 +6,6 @@ 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
  */

package/dist/cli/commands/init-config.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+
+/**
+ * Initialize Configuration Command
+ * Copies the framework's validation-config.json to the service directory for customization
+ */
+import { copyFile, access } from 'fs/promises';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import chalk from 'chalk';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Path to framework's bundled config
+const FRAMEWORK_CONFIG_PATH = join(__dirname, '../config/validation-config.json');
+
+/**
+ * Register the init-config command with the CLI
+ */
+export function registerInitConfigCommand(program) {
+  program.command('init-config').description('Initialize validation-config.json in your service directory').option('-f, --force', 'Overwrite existing validation-config.json', false).action(handler);
+}
+async function handler(options) {
+  const targetPath = join(process.cwd(), 'validation-config.json');
+  try {
+    // Check if file already exists
+    try {
+      await access(targetPath);
+      if (!options.force) {
+        console.log(chalk.yellow('⚠️  validation-config.json already exists.'));
+        console.log(chalk.gray('   Use --force to overwrite.'));
+        process.exit(0);
+      } else {
+        console.log(chalk.yellow('🔄 Overwriting existing validation-config.json...'));
+      }
+    } catch {
+      // File doesn't exist, proceed
+    }
+
+    // Copy framework config to service directory
+    await copyFile(FRAMEWORK_CONFIG_PATH, targetPath);
+    console.log(chalk.green('✅ Successfully initialized validation-config.json'));
+    console.log(chalk.gray('\n📝 Configuration file details:'));
+    console.log(chalk.gray(`   Location: ${targetPath}`));
+    console.log(chalk.gray('\n💡 Usage:'));
+    console.log(chalk.gray('   • Customize timing values (timeouts, intervals)'));
+    console.log(chalk.gray('   • Add service-specific endpoints for validation'));
+    console.log(chalk.gray('   • Configure platform-specific commands'));
+    console.log(chalk.gray('   • Set environment-specific requirements'));
+    console.log(chalk.gray('\n⚠️  Note: Most services don\'t need this file.'));
+    console.log(chalk.gray('   The framework provides sensible defaults.'));
+  } catch (error) {
+    console.error(chalk.red('❌ Failed to initialize configuration:'));
+    console.error(chalk.red(`   ${error.message}`));
+    process.exit(1);
+  }
+}

package/dist/{bin → cli}/commands/update.js

@@ -3,16 +3,16 @@
  */
 
 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';
+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';
 export function registerUpdateCommand(program) {
   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 output = new (await import('../lib/shared/utils/output-formatter.js')).OutputFormatter(options);
       const configLoader = new ConfigLoader({
         verbose: options.verbose,
         quiet: options.quiet,
@@ -60,7 +60,7 @@ export function registerUpdateCommand(program) {
       }
       output.success('Service update completed successfully!');
     } catch (error) {
-      const output = new (await import('../shared/utils/output-formatter.js')).OutputFormatter(options || {});
+      const output = new (await import('../lib/shared/utils/output-formatter.js')).OutputFormatter(options || {});
       output.error(`Service update failed: ${error.message}`);
       if (error.details) {
         output.warning(`Details: ${error.details}`);

package/dist/{bin → cli}/commands/validate.js

@@ -3,16 +3,16 @@
  */
 
 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';
+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';
 export function registerValidateCommand(program) {
   const command = program.command('validate <service-path>').description('Validate an existing service configuration').option('--deep-scan', 'Run comprehensive validation checks').option('--export-report <file>', 'Export validation report to JSON file');
 
   // 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 output = new (await import('../lib/shared/utils/output-formatter.js')).OutputFormatter(options);
       const configLoader = new ConfigLoader({
         verbose: options.verbose,
         quiet: options.quiet,
@@ -43,7 +43,7 @@ export function registerValidateCommand(program) {
         process.exit(1);
       }
     } catch (error) {
-      const output = new (await import('../shared/utils/output-formatter.js')).OutputFormatter(options || {});
+      const output = new (await import('../lib/shared/utils/output-formatter.js')).OutputFormatter(options || {});
       output.error(`Validation failed: ${error.message}`);
       process.exit(1);
     }