@tamyla/clodo-framework 3.1.21 → 3.1.23

package/dist/{bin → lib}/deployment/modules/DeploymentOrchestrator.js

@@ -6,8 +6,8 @@
 
 import { readFileSync, writeFileSync } from 'fs';
 import { deploySecret, runMigrations, checkHealth } from '../../shared/cloudflare/ops.js';
-import { WranglerDeployer } from "../../deployment/wrangler-deployer.js";
-import { DeploymentDatabaseManager } from '../../database/deployment-db-manager.js';
+import { WranglerDeployer } from '../deployment/wrangler-deployer.js';
+import { DeploymentDatabaseManager } from '../database/deployment-db-manager.js';
 import { DeploymentConfiguration } from './DeploymentConfiguration.js';
 
 /**

package/dist/{bin → lib}/deployment/modules/EnvironmentManager.js

@@ -3,8 +3,8 @@
  * Handles environment configuration, domain mapping, deployment mode selection, and cross-domain coordination
  */
 
-import { MultiDomainOrchestrator } from "../../../orchestration/multi-domain-orchestrator.js";
-import { CrossDomainCoordinator } from "../../../orchestration/cross-domain-coordinator.js";
+import { MultiDomainOrchestrator } from '../../orchestration/multi-domain-orchestrator.js';
+import { CrossDomainCoordinator } from '../../orchestration/cross-domain-coordinator.js';
 import { DomainDiscovery } from '../../shared/cloudflare/domain-discovery.js';
 import { askChoice, askUser, askYesNo, DeploymentInteractiveUtils } from '../../shared/utils/interactive-utils.js';
 export class EnvironmentManager {

package/dist/lib/deployment/orchestration/EnterpriseOrchestrator.js

@@ -0,0 +1,21 @@
+/**
+ * Enterprise Orchestrator - STUB
+ *
+ * This is a stub implementation for the basic clodo-framework package.
+ * Enterprise features are only available in the enterprise package.
+ *
+ * To use enterprise deployment features, please install the enterprise package:
+ * npm install @tamyla/clodo-framework-enterprise
+ */
+
+import { BaseDeploymentOrchestrator } from './BaseDeploymentOrchestrator.js';
+export class EnterpriseOrchestrator extends BaseDeploymentOrchestrator {
+  /**
+   * Constructor for enterprise orchestrator - STUB
+   * @throws {Error} Enterprise features not available in basic package
+   */
+  constructor(options = {}) {
+    super(options);
+    throw new Error('Enterprise deployment features are not available in the basic clodo-framework package.\n' + 'To use enterprise deployment capabilities (multi-region, high-availability, compliance, etc.),\n' + 'please install the enterprise package: npm install @tamyla/clodo-framework-enterprise');
+  }
+}

package/dist/lib/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 → lib}/shared/cloudflare/domain-discovery.js

@@ -9,7 +9,7 @@
 import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
-import { NameFormatters, UrlFormatters, ResourceFormatters, EnvironmentFormatters } from '../utils/Formatters.js';
+import { NameFormatters, UrlFormatters, ResourceFormatters, EnvironmentFormatters } from '../utils/formatters.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 

package/dist/{bin → lib}/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 → lib}/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 → lib}/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;
@@ -240,7 +242,7 @@ export async function listDatabases(options = {}) {
   if (apiToken && accountId) {
     const {
       CloudflareAPI
-    } = await import('../../../utils/cloudflare/api.js');
+    } = await import('../../utils/cloudflare/api.js');
     const cf = new CloudflareAPI(apiToken);
     return await cf.listD1Databases(accountId);
   }
@@ -265,7 +267,7 @@ export async function databaseExists(databaseName, options = {}) {
   if (apiToken && accountId) {
     const {
       CloudflareAPI
-    } = await import('../../../utils/cloudflare/api.js');
+    } = await import('../../utils/cloudflare/api.js');
     const cf = new CloudflareAPI(apiToken);
     return await cf.d1DatabaseExists(accountId, databaseName);
   }
@@ -288,7 +290,7 @@ export async function createDatabase(name, options = {}) {
   if (apiToken && accountId) {
     const {
       CloudflareAPI
-    } = await import('../../../utils/cloudflare/api.js');
+    } = await import('../../utils/cloudflare/api.js');
     const cf = new CloudflareAPI(apiToken);
     const result = await cf.createD1Database(accountId, name);
     return result.uuid; // Return UUID to match CLI behavior
@@ -403,7 +405,7 @@ export async function getDatabaseId(databaseName, options = {}) {
   if (apiToken && accountId) {
     const {
       CloudflareAPI
-    } = await import('../../../utils/cloudflare/api.js');
+    } = await import('../../utils/cloudflare/api.js');
     const cf = new CloudflareAPI(apiToken);
     const db = await cf.getD1Database(accountId, databaseName);
     return db?.uuid || null;

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

package/dist/{bin → lib}/shared/deployment/credential-collector.js

@@ -11,7 +11,7 @@
 import chalk from 'chalk';
 import { askUser, askPassword, askChoice, closePrompts } from '../utils/interactive-prompts.js';
 import { ApiTokenManager } from '../security/api-token-manager.js';
-import { CloudflareAPI } from "../../../utils/cloudflare/api.js";
+import { CloudflareAPI } from '../../utils/cloudflare/api.js';
 export class DeploymentCredentialCollector {
   constructor(options = {}) {
     this.servicePath = options.servicePath || '.';
@@ -32,13 +32,16 @@ export class DeploymentCredentialCollector {
     const startCredentials = {
       token: options.token || process.env.CLOUDFLARE_API_TOKEN || null,
       accountId: options.accountId || process.env.CLOUDFLARE_ACCOUNT_ID || null,
-      zoneId: options.zoneId || process.env.CLOUDFLARE_ZONE_ID || null
+      zoneId: options.zoneId || process.env.CLOUDFLARE_ZONE_ID || null,
+      zoneName: null // Will be populated when fetching zone
     };
 
     // All credentials provided - quick path
     if (startCredentials.token && startCredentials.accountId && startCredentials.zoneId) {
       if (!this.quiet) {
-        console.log(chalk.green('\n✅ All credentials provided via flags or environment variables'));
+        const tokenSource = options.token ? '--token flag' : 'environment variable';
+        console.log(chalk.blue(`\nℹ️  Using credentials from: ${tokenSource}`));
+        console.log(chalk.green('✅ All credentials provided via flags or environment variables'));
       }
       return startCredentials;
     }
@@ -65,6 +68,7 @@ export class DeploymentCredentialCollector {
     }
     let accountId = startCredentials.accountId;
     let zoneId = startCredentials.zoneId;
+    let zoneName = startCredentials.zoneName;
     try {
       const cloudflareAPI = new CloudflareAPI(token);
 
@@ -86,7 +90,9 @@ export class DeploymentCredentialCollector {
 
       // If zone ID not provided, fetch from Cloudflare
       if (!zoneId) {
-        zoneId = await this.fetchZoneId(cloudflareAPI);
+        const zoneInfo = await this.fetchZoneId(cloudflareAPI);
+        zoneId = zoneInfo.id;
+        zoneName = zoneInfo.name;
       }
     } catch (error) {
       console.error(chalk.red(`\n❌ Credential validation failed:`));
@@ -96,10 +102,21 @@ export class DeploymentCredentialCollector {
     if (!this.quiet) {
       console.log(chalk.green('\n✅ All credentials collected and validated\n'));
     }
+
+    // Return structured Cloudflare settings object
+    // This encapsulates all zone-specific configuration for multi-domain deployments
     return {
       token,
       accountId,
-      zoneId
+      zoneId,
+      zoneName,
+      // Convenience: cloudflareSettings object for passing to orchestrators
+      cloudflareSettings: {
+        token,
+        accountId,
+        zoneId,
+        zoneName
+      }
     };
   }
 
@@ -197,7 +214,10 @@ export class DeploymentCredentialCollector {
         if (!this.quiet) {
           console.log(chalk.green(`✅ Found domain: ${zones[0].name}\n`));
         }
-        return zones[0].id;
+        return {
+          id: zones[0].id,
+          name: zones[0].name
+        };
       }
 
       // Multiple zones - let user choose
@@ -210,7 +230,10 @@ export class DeploymentCredentialCollector {
       if (!this.quiet) {
         console.log(chalk.green(`✅ Selected: ${selectedZone.name}\n`));
       }
-      return selectedZone.id;
+      return {
+        id: selectedZone.id,
+        name: selectedZone.name
+      };
     } catch (error) {
       console.error(chalk.red('❌ Failed to fetch domains:'));
       console.error(chalk.yellow(error.message));

package/dist/lib/shared/deployment/index.js

@@ -0,0 +1,10 @@
+/**
+ * Deployment Module
+ * Exports all deployment-related orchestrators, validators, and managers
+ */
+
+export { DeploymentValidator } from './validator.js';
+export { MultiDomainOrchestrator } from '../orchestration/multi-domain-orchestrator.js';
+export { CrossDomainCoordinator } from '../orchestration/cross-domain-coordinator.js';
+export { DeploymentAuditor } from './auditor.js';
+export { RollbackManager } from './rollback-manager.js';

package/dist/lib/shared/deployment/rollback-manager.js

@@ -0,0 +1,7 @@
+/**
+ * Rollback Manager - Deployment Module Re-export
+ *
+ * Re-exports the RollbackManager for deployment operations
+ */
+
+export { RollbackManager } from '../../deployment/rollback-manager.js';

package/dist/lib/shared/deployment/utilities/d1-error-recovery.js

@@ -0,0 +1,177 @@
+/**
+ * D1 Error Recovery Workflow Module
+ * 
+ * Provides sophisticated D1 database binding error detection and recovery.
+ * Extracted from enterprise-deployment/master-deploy.js for modularity.
+ * 
+ * @module d1-error-recovery
+ */
+
+/**
+ * D1 Error Recovery Manager
+ * Handles D1 database binding errors during deployment with automatic recovery
+ */
+export class D1ErrorRecoveryManager {
+  /**
+   * @param {Object} options - Configuration options
+   * @param {Array} options.rollbackActions - Array to track rollback actions
+   * @param {Object} options.wranglerDeployer - Optional WranglerDeployer instance for testing
+   */
+  constructor(options = {}) {
+    this.rollbackActions = options.rollbackActions || [];
+    this.wranglerDeployer = options.wranglerDeployer;
+  }
+
+  /**
+   * Handle D1 database binding errors during deployment
+   * 
+   * @param {Error} error - Deployment error to analyze
+   * @param {Object} config - Deployment configuration
+   * @param {string} config.environment - Target environment
+   * @param {string} [config.configPath='wrangler.toml'] - Path to wrangler config
+   * @param {string} [config.cwd] - Working directory
+   * @returns {Promise<Object>} Recovery result { handled, retry, action, message }
+   */
+  async handleD1BindingError(error, config = {}) {
+    try {
+      // Use provided WranglerDeployer or import dynamically
+      let deployer;
+      if (this.wranglerDeployer) {
+        deployer = this.wranglerDeployer;
+      } else {
+        // Import WranglerDeployer for D1 error handling
+        const {
+          WranglerDeployer
+        } = await import('../../deployment/wrangler-deployer.js');
+        deployer = new WranglerDeployer({
+          cwd: config.cwd || process.cwd(),
+          environment: config.environment
+        });
+      }
+
+      // Attempt D1 error recovery
+      const recoveryResult = await deployer.handleD1BindingError(error, {
+        configPath: config.configPath || 'wrangler.toml',
+        environment: config.environment
+      });
+      if (recoveryResult.handled) {
+        console.log(`   🔧 D1 Error Recovery: ${recoveryResult.action}`);
+
+        // Handle configuration backup if created
+        if (recoveryResult.backupPath) {
+          console.log(`   📁 Configuration backup: ${recoveryResult.backupPath}`);
+
+          // Add rollback action to restore backup
+          this.rollbackActions.unshift({
+            type: 'restore-wrangler-config',
+            backupPath: recoveryResult.backupPath,
+            description: 'Restore wrangler.toml backup after D1 recovery'
+          });
+        }
+
+        // Determine if deployment should be retried
+        const shouldRetry = this.shouldRetryAfterRecovery(recoveryResult.action);
+        return {
+          handled: true,
+          retry: shouldRetry,
+          action: recoveryResult.action,
+          message: this.getRecoveryMessage(recoveryResult),
+          databaseName: recoveryResult.databaseName,
+          databaseId: recoveryResult.databaseId
+        };
+      }
+
+      // Error was not a D1 binding error
+      return {
+        handled: false,
+        retry: false
+      };
+    } catch (recoveryError) {
+      console.log(`   ⚠️ D1 error recovery failed: ${recoveryError.message}`);
+      return {
+        handled: true,
+        retry: false,
+        message: `D1 error recovery failed: ${recoveryError.message}`
+      };
+    }
+  }
+
+  /**
+   * Determine if deployment should be retried after recovery
+   * 
+   * @param {string} action - Recovery action taken
+   * @returns {boolean} True if deployment should retry
+   */
+  shouldRetryAfterRecovery(action) {
+    const retryableActions = ['created_and_configured', 'database_selected_and_configured', 'binding_updated'];
+    return retryableActions.includes(action);
+  }
+
+  /**
+   * Get user-friendly message for recovery result
+   * 
+   * @param {Object} recoveryResult - Recovery result from WranglerDeployer
+   * @returns {string} User-friendly message
+   */
+  getRecoveryMessage(recoveryResult) {
+    const messages = {
+      'created_and_configured': `Created D1 database '${recoveryResult.databaseName}' and updated configuration`,
+      'database_selected_and_configured': `Selected existing database '${recoveryResult.databaseName}' and updated configuration`,
+      'binding_updated': `Updated D1 database binding configuration`,
+      'cancelled': 'D1 error recovery was cancelled by user',
+      'creation_failed': `Failed to create D1 database: ${recoveryResult.error}`,
+      'selection_failed': `Failed to update database selection: ${recoveryResult.error}`,
+      'no_databases_available': 'No D1 databases available in account',
+      'manual': 'User chose to resolve D1 issues manually',
+      'not_d1_error': 'Error is not related to D1 database bindings'
+    };
+    return messages[recoveryResult.action] || `D1 recovery completed with action: ${recoveryResult.action}`;
+  }
+
+  /**
+   * Deploy worker with automatic D1 error recovery
+   * 
+   * @param {Function} deployFunction - Function to deploy worker
+   * @param {Object} config - Deployment configuration
+   * @returns {Promise<void>}
+   */
+  async deployWithRecovery(deployFunction, config = {}) {
+    try {
+      await deployFunction();
+      console.log('   ✅ Worker deployed successfully');
+    } catch (error) {
+      // Attempt D1 error recovery
+      const recoveryResult = await this.handleD1BindingError(error, config);
+      if (recoveryResult.handled && recoveryResult.retry) {
+        console.log('   🔄 Retrying deployment after D1 error recovery...');
+        try {
+          await deployFunction();
+          console.log('   ✅ Worker deployed successfully after D1 recovery');
+        } catch (retryError) {
+          console.log('   ❌ Deployment failed even after D1 recovery');
+          throw retryError;
+        }
+      } else if (recoveryResult.handled) {
+        // Error was handled but no retry requested
+        throw new Error(`Deployment failed: ${recoveryResult.message || error.message}`);
+      } else {
+        // Not a D1 error, rethrow original
+        throw error;
+      }
+    }
+  }
+
+  /**
+   * Get recovery statistics
+   * 
+   * @returns {Object} Recovery statistics
+   */
+  getStatistics() {
+    const d1RollbackActions = this.rollbackActions.filter(action => action.type === 'restore-wrangler-config');
+    return {
+      totalRecoveries: d1RollbackActions.length,
+      hasBackups: d1RollbackActions.length > 0,
+      latestBackup: d1RollbackActions[0]?.backupPath
+    };
+  }
+}

package/dist/{bin → lib}/shared/deployment/validator.js

@@ -10,8 +10,15 @@ import { access, readFile } from 'fs/promises';
 import { readFileSync } from 'fs';
 import { promisify } from 'util';
 import { exec } from 'child_process';
-import { join } from 'path';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
 import { getCommandConfig } from '../config/command-config-manager.js';
+
+// 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');
 const execAsync = promisify(exec);
 
 /**
@@ -58,6 +65,7 @@ export class DeploymentValidator {
   loadValidationConfig() {
     const configPath = join(process.cwd(), 'validation-config.json');
     try {
+      // First try to load from service directory
       const configData = readFileSync(configPath, 'utf-8');
       const userConfig = JSON.parse(configData);
 
@@ -85,15 +93,37 @@ export class DeploymentValidator {
       console.log('📋 Loaded validation config from validation-config.json');
       return defaultConfig;
     } catch (error) {
-      // Fall back to defaults if file doesn't exist or is invalid
-      console.log('📋 Using default validation config (validation-config.json not found or invalid)');
-      return {
-        requiredCommands: Object.keys(this.cmdConfig?.config?.requiredCommands || {}) || ['npx', 'node', 'npm', 'wrangler'],
-        requiredFiles: ['package.json', 'wrangler.toml'],
-        requiredEnvironmentVars: [],
-        networkEndpoints: ['https://api.cloudflare.com', 'https://registry.npmjs.org'],
-        expectedEndpoints: this.getExpectedEndpoints()
-      };
+      // If service config not found, try framework's internal config
+      try {
+        const frameworkConfigData = readFileSync(FRAMEWORK_CONFIG_PATH, 'utf-8');
+        const frameworkConfig = JSON.parse(frameworkConfigData);
+
+        // Extract relevant parts for validation
+        const defaultConfig = {
+          requiredCommands: Object.values(frameworkConfig.commands?.required || {}) || ['npx', 'node', 'npm', 'wrangler'],
+          requiredFiles: ['package.json', 'wrangler.toml'],
+          requiredEnvironmentVars: [],
+          networkEndpoints: Object.values(frameworkConfig.networking?.endpoints || {}),
+          expectedEndpoints: this.getExpectedEndpoints(),
+          // Include timing and other framework config
+          timing: frameworkConfig.timing,
+          networking: frameworkConfig.networking,
+          caching: frameworkConfig.caching,
+          environments: frameworkConfig.environments
+        };
+        console.log('📋 Loaded validation config from framework defaults');
+        return defaultConfig;
+      } catch (frameworkError) {
+        // If neither exists, use hardcoded defaults
+        console.log('📋 Using minimal validation config (no config files found)');
+        return {
+          requiredCommands: Object.keys(this.cmdConfig?.config?.requiredCommands || {}) || ['npx', 'node', 'npm', 'wrangler'],
+          requiredFiles: ['package.json', 'wrangler.toml'],
+          requiredEnvironmentVars: [],
+          networkEndpoints: ['https://api.cloudflare.com', 'https://registry.npmjs.org'],
+          expectedEndpoints: this.getExpectedEndpoints()
+        };
+      }
     }
   }