@tamyla/clodo-framework 3.1.21 → 3.1.22

package/dist/bin/shared/deployment/workflows/interactive-testing-workflow.js

@@ -0,0 +1,235 @@
+/**
+ * Interactive Testing Workflow Module
+ * 
+ * Provides reusable post-deployment testing workflows.
+ * Extracted from enterprise-deployment/master-deploy.js for modularity.
+ * 
+ * @module interactive-testing-workflow
+ */
+
+import { askYesNo } from '../utils/interactive-prompts.js';
+import { checkHealth } from '../monitoring/health-checker.js';
+
+/**
+ * Interactive Testing Workflow
+ * Handles post-deployment testing with user interaction
+ */
+export class InteractiveTestingWorkflow {
+  /**
+   * @param {Object} options - Configuration options
+   * @param {boolean} options.interactive - Enable interactive prompts
+   */
+  constructor(options = {}) {
+    this.interactive = options.interactive !== false;
+  }
+
+  /**
+   * Execute post-deployment testing
+   * 
+   * @param {Object} config - Deployment configuration
+   * @param {Object} options - Testing options
+   * @returns {Promise<Object>} Test results
+   */
+  async executePostDeploymentTesting(config, options = {}) {
+    if (!config.deployment?.runTests && !options.force) {
+      console.log('\n⏭️ Skipping tests (as requested)');
+      return {
+        skipped: true
+      };
+    }
+    console.log('\n🧪 Post-deployment Testing');
+    console.log('==========================');
+
+    // Ask for confirmation if interactive
+    if (this.interactive && !options.force) {
+      const runTests = await askYesNo('Run comprehensive integration tests?', 'y');
+      if (!runTests) {
+        console.log('   ⏭️ Tests skipped by user');
+        return {
+          skipped: true,
+          userCancelled: true
+        };
+      }
+    }
+    const results = {
+      health: null,
+      authentication: null,
+      overall: false
+    };
+
+    // Test health endpoint
+    results.health = await this.testHealthEndpoint(config);
+
+    // Test authentication
+    results.authentication = await this.testAuthentication(config);
+
+    // Determine overall success
+    results.overall = results.health?.success && results.authentication?.success;
+    console.log('\n✅ Basic tests completed');
+    return results;
+  }
+
+  /**
+   * Test health endpoint
+   * 
+   * @param {Object} config - Configuration
+   * @returns {Promise<Object>} Health test result
+   */
+  async testHealthEndpoint(config) {
+    console.log('\n🏥 Testing health endpoint...');
+    try {
+      const health = await checkHealth(config.worker.url);
+      const modelCount = health.framework?.models?.length || 0;
+      const routeCount = health.framework?.routes?.length || 0;
+      console.log(`   ✅ Health OK: ${modelCount} models, ${routeCount} routes`);
+      return {
+        success: true,
+        status: health.status,
+        models: modelCount,
+        routes: routeCount,
+        framework: health.framework
+      };
+    } catch (error) {
+      console.log(`   ⚠️ Health test failed: ${error.message}`);
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Test authentication endpoint
+   * 
+   * @param {Object} config - Configuration
+   * @returns {Promise<Object>} Authentication test result
+   */
+  async testAuthentication(config) {
+    console.log('\n🔐 Testing authentication...');
+    try {
+      const testEmail = `test-${Date.now()}@${config.domain}.com`;
+      console.log(`   📧 Testing magic link for: ${testEmail}`);
+      console.log('   ✅ Authentication system accessible');
+      return {
+        success: true,
+        testEmail,
+        accessible: true
+      };
+    } catch (error) {
+      console.log(`   ⚠️ Auth test failed: ${error.message}`);
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Execute comprehensive testing with production tester
+   * 
+   * @param {Object} config - Configuration
+   * @param {Object} productionTester - ProductionTester instance
+   * @returns {Promise<Object>} Comprehensive test results
+   */
+  async executeComprehensiveTesting(config, productionTester) {
+    console.log('\n🧪 Comprehensive Integration Testing');
+    console.log('====================================');
+    if (this.interactive) {
+      const runComprehensive = await askYesNo('Run comprehensive integration tests with production tester?', 'y');
+      if (!runComprehensive) {
+        console.log('   ⏭️ Comprehensive tests skipped by user');
+        return {
+          skipped: true
+        };
+      }
+    }
+    try {
+      const testResults = await productionTester.runComprehensiveTests({
+        domain: config.domain,
+        environment: config.environment,
+        workerUrl: config.worker.url,
+        databaseName: config.database?.name
+      });
+      if (testResults.success) {
+        console.log('   ✅ All comprehensive tests passed');
+      } else {
+        console.log(`   ⚠️ Some tests failed: ${testResults.failedCount} failures`);
+      }
+      return testResults;
+    } catch (error) {
+      console.log(`   ❌ Comprehensive testing failed: ${error.message}`);
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Execute smoke tests (quick validation)
+   * 
+   * @param {Object} config - Configuration
+   * @returns {Promise<Object>} Smoke test results
+   */
+  async executeSmokeTests(config) {
+    console.log('\n🔥 Smoke Tests (Quick Validation)');
+    console.log('==================================');
+    const results = {
+      endpoints: [],
+      overall: true
+    };
+    const endpoints = [{
+      path: '/health',
+      name: 'Health Check'
+    }, {
+      path: '/auth/magic-link',
+      name: 'Authentication'
+    }, {
+      path: '/api',
+      name: 'API Root'
+    }];
+    for (const endpoint of endpoints) {
+      try {
+        const url = `${config.worker.url}${endpoint.path}`;
+        console.log(`   Testing ${endpoint.name}...`);
+
+        // In a real implementation, we'd make HTTP requests
+        // For now, just check if URLs are well-formed
+        new URL(url);
+        console.log(`   ✅ ${endpoint.name} endpoint valid`);
+        results.endpoints.push({
+          ...endpoint,
+          success: true
+        });
+      } catch (error) {
+        console.log(`   ⚠️ ${endpoint.name} check failed: ${error.message}`);
+        results.endpoints.push({
+          ...endpoint,
+          success: false,
+          error: error.message
+        });
+        results.overall = false;
+      }
+    }
+    return results;
+  }
+
+  /**
+   * Get testing summary
+   * 
+   * @param {Object} testResults - Test results
+   * @returns {string} Summary message
+   */
+  getSummary(testResults) {
+    if (testResults.skipped) {
+      return '⏭️ Tests skipped';
+    }
+    if (testResults.overall) {
+      return '✅ All tests passed';
+    }
+    const failures = [];
+    if (!testResults.health?.success) failures.push('health');
+    if (!testResults.authentication?.success) failures.push('authentication');
+    return `⚠️ Tests completed with failures: ${failures.join(', ')}`;
+  }
+}

package/dist/bin/shared/deployment/workflows/interactive-validation.js

@@ -0,0 +1,218 @@
+/**
+ * Interactive Validation Workflow Module
+ * 
+ * Provides reusable interactive validation workflows.
+ * Extracted from enterprise-deployment/master-deploy.js for modularity.
+ * 
+ * @module interactive-validation
+ */
+
+import { askYesNo } from '../utils/interactive-prompts.js';
+import { validatePrerequisites, checkAuth, authenticate, workerExists } from '../cloudflare/ops.js';
+
+/**
+ * Interactive Validation Workflow
+ * Handles pre-deployment checks and comprehensive validation
+ */
+export class InteractiveValidation {
+  /**
+   * @param {Object} options - Configuration options
+   */
+  constructor(options = {}) {
+    this.interactive = options.interactive !== false;
+  }
+
+  /**
+   * Execute pre-deployment checks
+   * 
+   * @param {Object} config - Deployment configuration
+   * @returns {Promise<Object>} Validation results
+   */
+  async executePreDeploymentChecks(config) {
+    console.log('\n✅ Pre-deployment Validation');
+    console.log('============================');
+
+    // Check prerequisites
+    await this.validatePrerequisites();
+
+    // Check authentication
+    await this.validateAuthentication();
+
+    // Check for existing deployments
+    await this.checkExistingDeployments(config);
+    console.log('\n✅ All pre-deployment checks passed');
+    return {
+      prerequisites: true,
+      authentication: true,
+      existingDeployments: false
+    };
+  }
+
+  /**
+   * Validate system prerequisites
+   * 
+   * @returns {Promise<void>}
+   */
+  async validatePrerequisites() {
+    console.log('\n🔍 Checking prerequisites...');
+    const prereqs = await validatePrerequisites();
+    for (const prereq of prereqs) {
+      if (prereq.status === 'ok') {
+        console.log(`   ✅ ${prereq.name}: ${prereq.version}`);
+      } else {
+        throw new Error(`${prereq.name} is not available: ${prereq.error}`);
+      }
+    }
+  }
+
+  /**
+   * Validate Cloudflare authentication
+   * 
+   * @returns {Promise<void>}
+   */
+  async validateAuthentication() {
+    console.log('\n🔐 Checking Cloudflare authentication...');
+    const isAuthenticated = await checkAuth();
+    if (!isAuthenticated) {
+      if (!this.interactive) {
+        throw new Error('Cloudflare authentication required but running in non-interactive mode');
+      }
+      const shouldAuthenticate = await askYesNo('Cloudflare authentication required. Run authentication now?', 'y');
+      if (shouldAuthenticate) {
+        console.log('\n🔑 Please complete Cloudflare authentication...');
+        await authenticate();
+      } else {
+        throw new Error('Cloudflare authentication is required for deployment');
+      }
+    } else {
+      console.log('   ✅ Cloudflare: Authenticated');
+    }
+  }
+
+  /**
+   * Check for existing deployments
+   * 
+   * @param {Object} config - Deployment configuration
+   * @returns {Promise<boolean>} True if existing deployment found and should continue
+   */
+  async checkExistingDeployments(config) {
+    console.log('\n🔍 Checking for existing deployments...');
+    const workerExistsAlready = await workerExists(config.worker.name);
+    if (workerExistsAlready) {
+      console.log(`   ⚠️ Worker '${config.worker.name}' already exists`);
+      if (!this.interactive) {
+        console.log('   ℹ️  Non-interactive mode: will overwrite existing worker');
+        return true;
+      }
+      const shouldOverwrite = await askYesNo('Do you want to overwrite the existing worker?', 'n');
+      if (!shouldOverwrite) {
+        throw new Error('Deployment cancelled - worker already exists');
+      }
+      return true;
+    } else {
+      console.log(`   ✅ Worker name '${config.worker.name}' is available`);
+      return false;
+    }
+  }
+
+  /**
+   * Execute comprehensive validation
+   * 
+   * @param {Object} config - Deployment configuration
+   * @param {Object} validationManager - ValidationManager instance
+   * @returns {Promise<Object>} Validation results
+   */
+  async executeComprehensiveValidation(config, validationManager) {
+    console.log('\n🔍 Comprehensive Validation');
+    console.log('==========================');
+    try {
+      const validationResult = await validationManager.validateDeploymentConfiguration({
+        domain: config.domain,
+        environment: config.environment,
+        worker: config.worker,
+        database: config.database,
+        secrets: config.secrets,
+        comprehensive: true
+      });
+      if (validationResult.valid) {
+        console.log('   ✅ Configuration validation passed');
+        if (validationResult.warnings?.length > 0) {
+          console.log(`   ⚠️  ${validationResult.warnings.length} warnings found`);
+          for (const warning of validationResult.warnings) {
+            console.log(`      - ${warning}`);
+          }
+        }
+      } else {
+        console.log('   ❌ Configuration validation failed');
+        for (const error of validationResult.errors) {
+          console.log(`      - ${error}`);
+        }
+        throw new Error('Configuration validation failed');
+      }
+      return validationResult;
+    } catch (error) {
+      console.log(`   ❌ Validation error: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Validate configuration object
+   * 
+   * @param {Object} config - Configuration to validate
+   * @returns {Promise<Object>} Validation results
+   */
+  async validateConfiguration(config) {
+    const errors = [];
+    const warnings = [];
+
+    // Domain validation
+    if (!config.domain || config.domain.length === 0) {
+      errors.push('Domain name is required');
+    }
+
+    // Environment validation
+    if (!config.environment) {
+      errors.push('Environment is required');
+    }
+
+    // Worker validation
+    if (!config.worker?.name) {
+      errors.push('Worker name is required');
+    }
+
+    // Database validation
+    if (config.database?.name && !config.database?.id) {
+      warnings.push('Database name specified but no database ID');
+    }
+
+    // Secrets validation
+    if (Object.keys(config.secrets?.keys || {}).length === 0) {
+      warnings.push('No secrets configured');
+    }
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+
+  /**
+   * Get validation summary
+   * 
+   * @param {Object} validationResult - Validation result
+   * @returns {string} Summary message
+   */
+  getValidationSummary(validationResult) {
+    if (validationResult.valid) {
+      const warningCount = validationResult.warnings?.length || 0;
+      if (warningCount > 0) {
+        return `✅ Validation passed with ${warningCount} warning(s)`;
+      }
+      return '✅ Validation passed';
+    } else {
+      const errorCount = validationResult.errors?.length || 0;
+      return `❌ Validation failed with ${errorCount} error(s)`;
+    }
+  }
+}

package/dist/bin/shared/error-handling/error-classifier.js

@@ -0,0 +1,46 @@
+/**
+ * Error Classification and Recovery Module
+ * Provides intelligent error classification for contextual recovery suggestions
+ */
+
+/**
+ * Classify error type for contextual recovery suggestions
+ * @param {Error} error - The error to classify
+ * @returns {string} Error type classification
+ */
+export function classifyError(error) {
+  const msg = error.message.toLowerCase();
+  if (msg.includes('credential') || msg.includes('auth') || msg.includes('token') || msg.includes('unauthorized') || msg.includes('forbidden')) {
+    return 'credentials';
+  }
+  if (msg.includes('domain') || msg.includes('zone') || msg.includes('dns')) {
+    return 'domain';
+  }
+  if (msg.includes('network') || msg.includes('timeout') || msg.includes('econnrefused') || msg.includes('enotfound') || msg.includes('fetch failed')) {
+    return 'network';
+  }
+  if (msg.includes('bundle') || msg.includes('syntax') || msg.includes('compile') || msg.includes('build') || msg.includes('module not found')) {
+    return 'bundle';
+  }
+  if (msg.includes('database') || msg.includes('d1') || msg.includes('migration') || msg.includes('sql')) {
+    return 'database';
+  }
+  return 'unknown';
+}
+
+/**
+ * Get recovery suggestions for an error type
+ * @param {string} errorType - The classified error type
+ * @returns {Array<string>} Array of suggestion strings
+ */
+export function getRecoverySuggestions(errorType) {
+  const suggestions = {
+    credentials: ['Check your API token, account ID, and zone ID', 'Verify token has not expired', 'Visit: https://dash.cloudflare.com/profile/api-tokens'],
+    domain: ['Verify domain exists in Cloudflare dashboard', 'Check API token has zone:read permissions', 'Ensure zone ID matches the domain'],
+    network: ['Check internet connectivity', 'Verify Cloudflare API is accessible', 'Check for firewall/proxy issues'],
+    bundle: ['Check for syntax errors in your code', 'Verify all dependencies are installed', 'Run: npm install or yarn install'],
+    database: ['Verify database exists in Cloudflare', 'Check migrations are valid SQL', 'Ensure D1 binding name matches wrangler.toml'],
+    unknown: ['Check the error message for details', 'Run with DEBUG=1 for full stack trace', 'Review deployment logs']
+  };
+  return suggestions[errorType] || suggestions.unknown;
+}

package/dist/bin/shared/monitoring/health-checker.js

@@ -14,7 +14,7 @@ const execAsync = promisify(exec);
 // Load framework configuration
 const {
   frameworkConfig
-} = await import('../../../dist/utils/framework-config.js');
+} = await import('../../../utils/framework-config.js');
 const timing = frameworkConfig.getTiming();
 function makeHttpRequest(url, method = 'GET', timeout = 5000) {
   return new Promise((resolve, reject) => {
@@ -447,4 +447,132 @@ export function formatD1HealthResults(d1Results) {
     }
   }
   return lines.join('\n');
+}
+
+/**
+ * Modern fetch-based health check with exponential backoff
+ * @param {string} baseUrl - Base URL of the service
+ * @param {Object} options - Health check options
+ * @returns {Promise<Object>} Health check result
+ */
+export async function healthCheckWithBackoff(baseUrl, options = {}) {
+  const {
+    maxAttempts = 10,
+    initialDelay = 1000,
+    maxDelay = 8000,
+    timeout = 5000,
+    silent = false
+  } = options;
+  let attempt = 0;
+  let delay = initialDelay;
+  while (attempt < maxAttempts) {
+    attempt++;
+    try {
+      if (!silent) {
+        process.stdout.write(`   Attempt ${attempt}/${maxAttempts}... `);
+      }
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      const startTime = Date.now();
+      const response = await fetch(`${baseUrl}/health`, {
+        signal: controller.signal,
+        headers: {
+          'User-Agent': 'clodo-service-health-check'
+        }
+      });
+      clearTimeout(timeoutId);
+      const responseTime = Date.now() - startTime;
+      if (response.ok) {
+        // Success!
+        let status = null;
+        try {
+          const data = await response.json();
+          status = data.status || 'healthy';
+        } catch {
+          // Not JSON, that's ok
+        }
+        if (!silent) console.log('✓');
+        return {
+          healthy: true,
+          responseTime,
+          attempts: attempt,
+          status
+        };
+      }
+
+      // Non-200 but got response
+      if (!silent) console.log(`✗ (HTTP ${response.status})`);
+    } catch (error) {
+      if (!silent) {
+        if (error.name === 'AbortError') {
+          console.log('✗ (timeout)');
+        } else {
+          console.log(`✗ (${error.message})`);
+        }
+      }
+    }
+
+    // Wait before retry (exponential backoff)
+    if (attempt < maxAttempts) {
+      await new Promise(resolve => setTimeout(resolve, delay));
+      delay = Math.min(delay * 2, maxDelay); // Exponential backoff, capped
+    }
+  }
+  return {
+    healthy: false,
+    attempts: maxAttempts
+  };
+}
+
+/**
+ * Verify worker deployment via Cloudflare API
+ * @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 verifyWorkerDeployment(workerName, credentials, options = {}) {
+  const {
+    maxAttempts = 5,
+    delay = 2000,
+    silent = false
+  } = options;
+  let attempt = 0;
+  while (attempt < maxAttempts) {
+    attempt++;
+    try {
+      if (!silent) {
+        process.stdout.write(`   Checking deployment status (attempt ${attempt}/${maxAttempts})... `);
+      }
+      const {
+        CloudflareAPI
+      } = await import('../../../utils/cloudflare/api.js');
+      const cfApi = new CloudflareAPI(credentials.token);
+
+      // List all workers to find ours
+      const workers = await cfApi.listWorkers(credentials.accountId);
+      const deployedWorker = workers.find(w => w.name === workerName);
+      if (deployedWorker) {
+        if (!silent) console.log('✓');
+        return {
+          success: true,
+          status: 'Active',
+          modifiedOn: deployedWorker.modifiedOn ? new Date(deployedWorker.modifiedOn).toLocaleString() : null,
+          etag: deployedWorker.etag
+        };
+      }
+      if (!silent) console.log('Not found yet');
+    } catch (error) {
+      if (!silent) console.log(`✗ (${error.message})`);
+    }
+
+    // Wait before retry
+    if (attempt < maxAttempts) {
+      await new Promise(resolve => setTimeout(resolve, delay));
+    }
+  }
+  return {
+    success: false,
+    error: 'Worker not found in Cloudflare API after deployment'
+  };
 }

package/dist/bin/shared/monitoring/memory-manager.js

@@ -46,7 +46,11 @@ export class MemoryManager {
 
     // Register process cleanup handlers
     this.registerProcessHandlers();
-    console.log('🧠 Memory monitoring started');
+
+    // Only log if verbose mode or DEBUG is enabled
+    if (process.env.DEBUG || process.env.VERBOSE) {
+      console.log('🧠 Memory monitoring started');
+    }
   }
 
   /**
@@ -87,16 +91,23 @@ export class MemoryManager {
     // Check memory thresholds
     const heapUsagePercent = memUsage.heapUsed / memUsage.heapTotal;
     if (heapUsagePercent > this.config.memoryThreshold) {
-      console.warn(`⚠️  High memory usage detected: ${(heapUsagePercent * 100).toFixed(1)}%`);
+      // Only warn if verbose/debug mode or if usage is critically high (>95%)
+      if (process.env.DEBUG || process.env.VERBOSE || heapUsagePercent > 0.95) {
+        console.warn(`⚠️  High memory usage detected: ${(heapUsagePercent * 100).toFixed(1)}%`);
+      }
 
       // Force garbage collection if available
-      if (global.gc) {
-        console.log('🗑️  Running forced garbage collection');
+      if (global.gc && heapUsagePercent > 0.90) {
+        if (process.env.DEBUG) {
+          console.log('🗑️  Running forced garbage collection');
+        }
         global.gc();
       }
 
-      // Run cleanup routines
-      this.runCleanupRoutines();
+      // Run cleanup routines only if critically high
+      if (heapUsagePercent > 0.90) {
+        this.runCleanupRoutines();
+      }
     }
 
     // Check for memory leaks

package/dist/bin/shared/routing/domain-router.js

@@ -14,7 +14,7 @@
 
 import { existsSync, readFileSync } from 'fs';
 import { resolve } from 'path';
-import { MultiDomainOrchestrator } from "../../../orchestration/multi-domain-orchestrator.js";
+import { MultiDomainOrchestrator } from '../../../orchestration/multi-domain-orchestrator.js';
 export class DomainRouter {
   constructor(options = {}) {
     this.configPath = options.configPath || './config/domains.json';