@tamyla/clodo-framework 3.1.21 → 3.1.22

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

@@ -0,0 +1,251 @@
+/**
+ * Deployment Verification Helpers (UI Wrapper)
+ * Provides UI-specific deployment verification by delegating to shared infrastructure
+ */
+
+import { verifyWorkerDeployment, healthCheckWithBackoff } from '../../shared/monitoring/health-checker.js';
+import { checkHealth } from '../../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/bin/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 '../../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/bin/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/commands/validate.js

@@ -3,7 +3,7 @@
  */
 
 import chalk from 'chalk';
-import { ServiceOrchestrator } from "../../service-management/ServiceOrchestrator.js";
+import { ServiceOrchestrator } from '../../service-management/ServiceOrchestrator.js';
 import { StandardOptions } from '../shared/utils/cli-options.js';
 import { ConfigLoader } from '../shared/utils/config-loader.js';
 export function registerValidateCommand(program) {

package/dist/bin/security/security-cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { SecurityCLI } from "../../security/SecurityCLI.js";
+import { SecurityCLI } from '../../security/SecurityCLI.js';
 const command = process.argv[2];
 const args = process.argv.slice(3);
 async function main() {

package/dist/bin/shared/cache/configuration-cache.js

@@ -0,0 +1,82 @@
+/**
+ * Configuration Cache
+ *
+ * Basic configuration caching implementation for enterprise modules
+ */
+
+export class ConfigurationCache {
+  constructor(options = {}) {
+    this.cache = new Map();
+    this.options = {
+      maxSize: options.maxSize || 1000,
+      ttl: options.ttl || 3600000,
+      // 1 hour default
+      ...options
+    };
+  }
+  async set(key, value, ttl = null) {
+    const expiry = ttl || this.options.ttl;
+    const entry = {
+      value,
+      expiry: Date.now() + expiry,
+      created: Date.now()
+    };
+
+    // Simple LRU: if at max size, remove oldest entry
+    if (this.cache.size >= this.options.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      this.cache.delete(firstKey);
+    }
+    this.cache.set(key, entry);
+    return true;
+  }
+  async get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return null;
+
+    // Check if expired
+    if (Date.now() > entry.expiry) {
+      this.cache.delete(key);
+      return null;
+    }
+    return entry.value;
+  }
+  async has(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return false;
+    if (Date.now() > entry.expiry) {
+      this.cache.delete(key);
+      return false;
+    }
+    return true;
+  }
+  async delete(key) {
+    return this.cache.delete(key);
+  }
+  async clear() {
+    this.cache.clear();
+    return true;
+  }
+  async size() {
+    // Clean expired entries
+    const now = Date.now();
+    for (const [key, entry] of this.cache.entries()) {
+      if (now > entry.expiry) {
+        this.cache.delete(key);
+      }
+    }
+    return this.cache.size;
+  }
+  async keys() {
+    const now = Date.now();
+    const validKeys = [];
+    for (const [key, entry] of this.cache.entries()) {
+      if (now <= entry.expiry) {
+        validKeys.push(key);
+      } else {
+        this.cache.delete(key);
+      }
+    }
+    return validKeys;
+  }
+}

package/dist/bin/shared/cloudflare/domain-manager.js

@@ -15,7 +15,7 @@ import { promisify } from 'util';
 import { exec } from 'child_process';
 import { askChoice, askYesNo } from '../utils/interactive-prompts.js';
 import { DomainDiscovery } from './domain-discovery.js';
-import { MultiDomainOrchestrator } from "../../../orchestration/multi-domain-orchestrator.js";
+import { MultiDomainOrchestrator } from '../../../orchestration/multi-domain-orchestrator.js';
 import { getCommandConfig } from '../config/command-config-manager.js';
 import { CloudflareTokenManager } from '../security/api-token-manager.js';
 const execAsync = promisify(exec);

package/dist/bin/shared/cloudflare/index.js

@@ -5,4 +5,4 @@
 
 export { CloudflareDomainManager } from './domain-manager.js';
 export { DomainDiscovery } from './domain-discovery.js';
-export { CloudflareOps } from './ops.js';
+export * from './ops.js';

package/dist/bin/shared/cloudflare/ops.js

@@ -44,15 +44,17 @@ const dbManager = new DatabaseConnectionManager({
   maxPoolSize: 5
 });
 
-// Memory management
-const memoryManager = startMemoryMonitoring({
+// Memory management - Disabled for CLI commands (short-lived processes)
+// Only enable for long-running server processes
+const memoryManager = process.env.ENABLE_MEMORY_MONITORING === 'true' ? startMemoryMonitoring({
   gcInterval: 300000,
   // 5 minutes
-  memoryThreshold: 0.8,
+  memoryThreshold: 0.9,
+  // 90% threshold (increased from 80%)
   cleanupInterval: 60000,
   // 1 minute
   leakDetection: true
-});
+}) : null;
 
 // Graceful shutdown handling (lazy initialization to avoid sync issues)
 let shutdownManager = null;

package/dist/bin/shared/config/ConfigurationManager.js

@@ -71,7 +71,29 @@ export class ConfigurationManager {
     this._validateConfiguration();
   }
 
-  // ============ FEATURE FLAG MANAGEMENT ============
+  /**
+   * Deep merge two configuration objects
+   * @param {Object} defaults - Default configuration
+   * @param {Object} userConfig - User-provided configuration
+   * @returns {Object} Merged configuration
+   */
+  mergeConfigurations(defaults, userConfig) {
+    const output = {
+      ...defaults
+    };
+    for (const key in userConfig) {
+      if (userConfig[key] && typeof userConfig[key] === 'object' && !Array.isArray(userConfig[key])) {
+        // Recursively merge objects
+        output[key] = this.mergeConfigurations(defaults[key] || {}, userConfig[key]);
+      } else {
+        // Overwrite arrays and primitives
+        output[key] = userConfig[key];
+      }
+    }
+    return output;
+  }
+
+  // ============ UTILITY METHODS ============
 
   /**
    * Check if a feature is enabled

package/dist/bin/shared/config/command-config-manager.js

@@ -7,7 +7,14 @@
  */
 
 import { readFileSync } from 'fs';
-import { join } from 'path';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+// Get the directory of this module (framework's bin directory)
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// Navigate up to framework root, then to config directory
+const FRAMEWORK_CONFIG_PATH = join(__dirname, '../../../config/validation-config.json');
 export class CommandConfigManager {
   constructor(configPath = null) {
     this.configPath = configPath || join(process.cwd(), 'validation-config.json');
@@ -20,12 +27,21 @@ export class CommandConfigManager {
    */
   loadConfig() {
     try {
+      // First try to load from service directory
       const configData = readFileSync(this.configPath, 'utf-8');
       this.config = JSON.parse(configData);
       console.log('📋 Loaded command configuration from validation-config.json');
     } catch (error) {
-      console.log('⚠️ Could not load command config, using defaults');
-      this.config = this.getDefaultConfig();
+      // If service config not found, try framework's internal config
+      try {
+        const frameworkConfigData = readFileSync(FRAMEWORK_CONFIG_PATH, 'utf-8');
+        this.config = JSON.parse(frameworkConfigData);
+        console.log('📋 Loaded command configuration from framework defaults');
+      } catch (frameworkError) {
+        // If neither exists, use hardcoded defaults
+        console.log('⚠️ Could not load command config, using minimal defaults');
+        this.config = this.getDefaultConfig();
+      }
     }
   }
 

package/dist/bin/shared/config/index.js

@@ -7,7 +7,7 @@
 export { ConfigCache } from './cache.js';
 export { ConfigManager } from './manager.js';
 export { CommandConfigManager } from './command-config-manager.js';
-export { CustomerConfigurationManager } from '../../../src/config/customers.js';
+export { CustomerConfigurationManager } from '../../../config/customers.js';
 
 // Phase 3.2 consolidated configuration management
 export { ConfigurationManager, configManager, isFeatureEnabled, getEnabledFeatures, withFeature, FEATURES, COMMON_FEATURES } from './ConfigurationManager.js';