@tamyla/clodo-framework 3.1.21 → 3.1.23

package/dist/lib/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/lib/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 → lib}/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 → lib}/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 → lib}/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';

package/dist/lib/shared/utils/deployment-validator.js

@@ -0,0 +1,97 @@
+/**
+ * Deployment Validator Utility
+ * Pre-deployment validation and prerequisite checking
+ * Extracted from clodo-service-old.js for modular reuse
+ */
+
+import { existsSync } from 'fs';
+import { join } from 'path';
+import chalk from 'chalk';
+
+/**
+ * Validate deployment prerequisites before proceeding
+ * @param {Object} coreInputs - Core deployment inputs
+ * @param {Object} options - Deployment options
+ * @returns {Promise<boolean>} True if all prerequisites are valid
+ */
+export async function validateDeploymentPrerequisites(coreInputs, options) {
+  const issues = [];
+  console.log(chalk.cyan('\n🔍 Pre-deployment Validation'));
+  console.log(chalk.gray('─'.repeat(40)));
+
+  // Check required fields
+  if (!coreInputs.customer) {
+    issues.push('Customer name is required');
+  }
+  if (!coreInputs.environment) {
+    issues.push('Environment is required');
+  }
+  if (!coreInputs.domainName) {
+    issues.push('Domain name is required');
+  }
+  if (!coreInputs.cloudflareToken) {
+    issues.push('Cloudflare API token is required');
+  }
+
+  // Check Cloudflare token format (basic validation)
+  if (coreInputs.cloudflareToken && !coreInputs.cloudflareToken.startsWith('CLOUDFLARE_API_TOKEN=')) {
+    if (coreInputs.cloudflareToken.length < 40) {
+      issues.push('Cloudflare API token appears to be invalid (too short)');
+    }
+  }
+
+  // Check if service path exists
+  if (options.servicePath && options.servicePath !== '.') {
+    if (!existsSync(options.servicePath)) {
+      issues.push(`Service path does not exist: ${options.servicePath}`);
+    }
+  }
+
+  // Check for wrangler.toml if not dry run
+  if (!options.dryRun) {
+    const wranglerPath = join(options.servicePath || '.', 'wrangler.toml');
+    if (!existsSync(wranglerPath)) {
+      issues.push('wrangler.toml not found in service directory');
+    }
+  }
+
+  // Report issues
+  if (issues.length > 0) {
+    console.log(chalk.red('\n❌ Validation Failed:'));
+    issues.forEach(issue => {
+      console.log(chalk.red(`   • ${issue}`));
+    });
+    console.log(chalk.gray('\n─'.repeat(40)));
+    return false;
+  }
+  console.log(chalk.green('✅ All prerequisites validated'));
+  console.log(chalk.gray('─'.repeat(40)));
+  return true;
+}
+
+/**
+ * Validate basic deployment inputs
+ * @param {Object} inputs - Input object to validate
+ * @param {Array<string>} requiredFields - Required field names
+ * @returns {Object} Validation result { valid, errors }
+ */
+export function validateDeploymentInputs(inputs, requiredFields = ['customer', 'environment', 'domainName', 'cloudflareToken']) {
+  const result = {
+    valid: true,
+    errors: []
+  };
+
+  // Handle null/undefined inputs
+  if (!inputs) {
+    result.errors.push('Input object is required');
+    result.valid = false;
+    return result;
+  }
+  requiredFields.forEach(field => {
+    if (!inputs[field]) {
+      result.errors.push(`${field} is required`);
+      result.valid = false;
+    }
+  });
+  return result;
+}

package/dist/{bin → lib}/shared/utils/formatters.js

@@ -118,6 +118,16 @@ export const ResourceFormatters = {
    */
   configKey(camelCase) {
     return NameFormatters.toKebabCase(camelCase);
+  },
+  /**
+   * Format package name for NPM
+   * Example: 'my-service' → 'my-service'
+   */
+  packageName(serviceName) {
+    if (!serviceName) return '';
+    // For NPM packages, just use the service name as-is
+    // Scoped packages would be handled separately (e.g., @company/my-service)
+    return serviceName;
   }
 };
 

package/dist/{bin → lib}/shared/utils/index.js

@@ -16,4 +16,16 @@ export { GracefulShutdownManager, getShutdownManager, initializeGracefulShutdown
 export { executeWithRateLimit, queueRequest, getRateLimitStatus, clearQueues, RATE_LIMITS } from './rate-limiter.js';
 
 // Unified error handling module (Phase 3.2.3d - consolidated from 5 sources)
-export { default as ErrorHandler, createErrorResponse, createContextualError, createErrorHandler } from './ErrorHandler.js';
+export { default as ErrorHandler, createErrorResponse, createContextualError, createErrorHandler } from './ErrorHandler.js';
+
+// Progress display utilities
+export { showProgressSpinner, showProgressWithSpinner } from './progress-spinner.js';
+
+// Deployment validation
+export { validateDeploymentPrerequisites, validateDeploymentInputs } from './deployment-validator.js';
+
+// Sensitive information redaction
+export { redactSensitiveInfo, redactSensitiveObject } from './sensitive-redactor.js';
+
+// Configuration loading
+export { ConfigLoader } from './config-loader.js';

package/dist/{bin → lib}/shared/utils/interactive-prompts.js

@@ -98,6 +98,7 @@ export function showProgress(message, steps = ['⏳', '⚡', '✅']) {
 
 /**
  * Ask for sensitive input (like API tokens) with hidden input
+ * Supports pasting with Ctrl+V or right-click paste
  */
 export function askPassword(question) {
   return new Promise(resolve => {
@@ -107,26 +108,41 @@ export function askPassword(question) {
     // Hide input for sensitive data
     process.stdin.setRawMode(true);
     process.stdin.resume();
+    process.stdin.setEncoding('utf8');
     let password = '';
-    const onData = char => {
-      const charCode = char[0];
-      if (charCode === 13) {
-        // Enter key
-        process.stdin.setRawMode(false);
-        process.stdin.pause();
-        process.stdin.removeListener('data', onData);
-        process.stdout.write('\n');
-        resolve(password);
-      } else if (charCode === 127 || charCode === 8) {
-        // Backspace
-        if (password.length > 0) {
-          password = password.slice(0, -1);
-          process.stdout.write('\b \b');
+    const onData = chunk => {
+      // Handle multi-character input (paste operations)
+      for (let i = 0; i < chunk.length; i++) {
+        const char = chunk[i];
+        const charCode = char.charCodeAt(0);
+        if (charCode === 13 || charCode === 10) {
+          // Enter key (CR or LF)
+          process.stdin.setRawMode(false);
+          process.stdin.pause();
+          process.stdin.removeListener('data', onData);
+          process.stdout.write('\n');
+          resolve(password);
+          return;
+        } else if (charCode === 127 || charCode === 8) {
+          // Backspace
+          if (password.length > 0) {
+            password = password.slice(0, -1);
+            process.stdout.write('\b \b');
+          }
+        } else if (charCode === 3) {
+          // Ctrl+C
+          process.stdin.setRawMode(false);
+          process.stdin.pause();
+          process.stdin.removeListener('data', onData);
+          process.stdout.write('\n');
+          console.log('\nOperation cancelled');
+          process.exit(0);
+        } else if (charCode >= 32 && charCode <= 126) {
+          // Printable characters
+          password += char;
+          process.stdout.write('*');
         }
-      } else if (charCode >= 32 && charCode <= 126) {
-        // Printable characters
-        password += char.toString();
-        process.stdout.write('*');
+        // Ignore other control characters (allows paste to work)
       }
     };
     process.stdin.on('data', onData);

package/dist/{bin → lib}/shared/utils/progress-manager.js

@@ -71,11 +71,11 @@ export class ProgressManager {
    * @returns {ProgressManager} This instance for chaining
    */
   nextStep(stepName = null) {
+    this.currentStep++;
+    this.stepStartTime = Date.now();
     if (this.quiet) {
       return this;
     }
-    this.currentStep++;
-    this.stepStartTime = Date.now();
     const name = stepName || this.steps[this.currentStep - 1] || `Step ${this.currentStep}`;
     const progress = this.totalSteps > 0 ? Math.round(this.currentStep / this.totalSteps * 100) : 0;
     if (this.output) {