@tamyla/clodo-framework 3.2.5 → 4.0.0

package/CHANGELOG.md

@@ -1,3 +1,37 @@
+# [4.0.0](https://github.com/tamylaa/clodo-framework/compare/v3.2.5...v4.0.0) (2025-12-07)
+
+
+### Bug Fixes
+
+* resolve remaining 5 import path issues in dist files ([383a625](https://github.com/tamylaa/clodo-framework/commit/383a6257910546f4d9a9f1442f4005c0cc166704))
+
+
+### Code Refactoring
+
+* replace band-aid import fixes with proper wrapper pattern ([5385ef2](https://github.com/tamylaa/clodo-framework/commit/5385ef23e9a9b8be26fce9d9fe6df2184667168c))
+
+
+### BREAKING CHANGES
+
+* from previous approach:
+- Removed post-build path manipulation that was fragile and hard to maintain
+- Implemented proper wrapper re-export pattern consistent with existing codebase
+
+Changes:
+- Create lib/shared/utils/framework-config.js wrapper that re-exports from src/utils
+- Update connection-manager.js to import from ../utils/framework-config.js wrapper
+- Update secret-generator.js to import from ../utils/framework-config.js wrapper
+- Update graceful-shutdown-manager.js to import from ./framework-config.js wrapper
+- Replace complex import path fixes with single minimal transformation in fix-dist-imports.js
+- Maintains all 23 exports working correctly
+
+Benefits:
+ Clean, maintainable architecture following existing wrapper patterns
+ No circular dependencies
+ Imports work correctly in both source and compiled dist/
+ Easier to debug and understand import resolution
+ Scales better as codebase grows
+
 ## [3.2.5](https://github.com/tamylaa/clodo-framework/compare/v3.2.4...v3.2.5) (2025-12-06)
 
 

package/dist/config/domains.js

@@ -1,5 +1,24 @@
 // Simple inline logger to avoid circular dependency with index.js
-import { validateRequired, deepMerge } from '../utils/index.js';
+// Import only pure JS utilities (no Node.js dependencies)
+const deepMerge = (target, source) => {
+  const result = {
+    ...target
+  };
+  for (const key in source) {
+    if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+      result[key] = deepMerge(result[key] || {}, source[key]);
+    } else {
+      result[key] = source[key];
+    }
+  }
+  return result;
+};
+const validateRequired = (obj, requiredFields) => {
+  const missing = requiredFields.filter(field => !obj[field]);
+  if (missing.length > 0) {
+    throw new Error(`Missing required fields: ${missing.join(', ')}`);
+  }
+};
 const logger = {
   info: (message, ...args) => console.log(`[DomainConfig] ${message}`, ...args),
   error: (message, ...args) => console.error(`[DomainConfig] ${message}`, ...args),

package/dist/database/database-orchestrator.js

@@ -128,7 +128,7 @@ export class DatabaseOrchestrator {
       // Import framework config for consistent timing and database settings
       const {
         frameworkConfig
-      } = await import('../utils/framework-config.js');
+      } = await import('../lib/shared/utils/framework-config.js');
       const timing = frameworkConfig.getTiming();
       const database = frameworkConfig.getDatabaseConfig();
       const configPaths = frameworkConfig.getPaths();

package/dist/deployment/index.js

@@ -1,6 +1,10 @@
 // Deployment Module
 // Core deployment components for the Clodo Framework
 
+// Validation and Auditing
+export { DeploymentValidator } from './validator.js';
+export { DeploymentAuditor } from './auditor.js';
+
 // NOTE: WranglerDeployer has lib/ dependencies not available in npm distribution
 // export { WranglerDeployer } from './wrangler-deployer.js';
 

package/dist/deployment/orchestration/BaseDeploymentOrchestrator.js

@@ -19,7 +19,7 @@
  * @abstract
  */
 
-import { ErrorHandler } from '../../../lib/shared/utils/ErrorHandler.js';
+import { ErrorHandler } from '../../lib/shared/utils/ErrorHandler.js';
 
 /**
  * Phase state and execution order

package/dist/deployment/orchestration/UnifiedDeploymentOrchestrator.js

@@ -36,7 +36,7 @@
 import { BaseDeploymentOrchestrator } from './BaseDeploymentOrchestrator.js';
 import { SingleServiceOrchestrator } from './SingleServiceOrchestrator.js';
 import { PortfolioOrchestrator } from './PortfolioOrchestrator.js';
-import { ErrorHandler } from '../../../lib/shared/utils/ErrorHandler.js';
+import { ErrorHandler } from '../../lib/shared/utils/ErrorHandler.js';
 
 /**
  * Capability descriptors - Defines what each capability provides

package/dist/lib/shared/database/connection-manager.js

@@ -4,7 +4,7 @@
  */
 
 import { executeSql } from '../cloudflare/ops.js';
-import { ErrorRecoveryManager } from '../utils/index.js';
+import { ErrorRecoveryManager, frameworkConfig } from '../utils/index.js';
 export class DatabaseConnectionManager {
   constructor(options = {}) {
     this.options = options;
@@ -18,10 +18,7 @@ export class DatabaseConnectionManager {
    * Initialize with framework configuration
    */
   async initialize() {
-    // Import framework config for consistent database connection settings
-    const {
-      frameworkConfig
-    } = await import('../../utils/framework-config.js');
+    // Use framework config for consistent database connection settings
     const timing = frameworkConfig.getTiming();
     const database = frameworkConfig.getDatabaseConfig();
     this.config = {
@@ -36,9 +33,6 @@ export class DatabaseConnectionManager {
     };
 
     // Initialize error recovery with loaded config
-    const {
-      ErrorRecoveryManager
-    } = await import('../utils/index.js');
     this.errorRecovery = new ErrorRecoveryManager({
       maxRetries: this.config.maxRetries,
       retryDelay: this.config.retryDelay,

package/dist/lib/shared/database/orchestrator.js

@@ -13,6 +13,7 @@ import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { promisify } from 'util';
 import { logger } from '../logging/Logger.js';
+import { frameworkConfig } from '../utils/framework-config.js';
 const execAsync = promisify(exec);
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -108,10 +109,7 @@ export class DatabaseOrchestrator {
    * Initialize with framework configuration
    */
   async initialize() {
-    // Import framework config for consistent timing and database settings
-    const {
-      frameworkConfig
-    } = await import('../../utils/framework-config.js');
+    // Use framework config for consistent timing and database settings
     const timing = frameworkConfig.getTiming();
     const database = frameworkConfig.getDatabaseConfig();
     this.config = {

package/dist/lib/shared/security/secret-generator.js

@@ -15,6 +15,7 @@ import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, statSy
 import { join, dirname } from 'path';
 import { execSync } from 'child_process';
 import { fileURLToPath } from 'url';
+import { frameworkConfig } from '../utils/framework-config.js';
 const __dirname = (() => {
   try {
     const filename = fileURLToPath(import.meta.url);
@@ -107,10 +108,7 @@ export class EnhancedSecretManager {
    * Initialize with framework configuration
    */
   async initialize() {
-    // Import framework config for consistent timing and retry settings
-    const {
-      frameworkConfig
-    } = await import('../../utils/framework-config.js');
+    // Use framework config for consistent timing and retry settings
     const timing = frameworkConfig.getTiming();
     const security = frameworkConfig.getSecurity();
     const configPaths = frameworkConfig.getPaths();

package/dist/lib/shared/security/secure-token-manager.js

@@ -8,6 +8,7 @@ import { join } from 'path';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 import crypto from 'crypto';
+import { frameworkConfig } from '../utils/framework-config.js';
 const execAsync = promisify(exec);
 export class SecureTokenManager {
   constructor(options = {}) {
@@ -34,9 +35,6 @@ export class SecureTokenManager {
   async initialize() {
     try {
       // Load framework configuration
-      const {
-        frameworkConfig
-      } = await import('../../utils/framework-config.js');
       this.frameworkConfig = frameworkConfig;
 
       // Update paths with framework config

package/dist/lib/shared/utils/error-recovery.js

@@ -11,6 +11,7 @@
  * This is the canonical version. All imports should use this version.
  */
 
+import { frameworkConfig } from './framework-config.js';
 export class ErrorRecoveryManager {
   constructor(options = {}) {
     this.options = options;
@@ -23,11 +24,8 @@ export class ErrorRecoveryManager {
    * Initialize with framework configuration
    */
   async initialize() {
-    // Import framework config for consistent timing and retry settings
+    // Use framework config for consistent timing and retry settings
     try {
-      const {
-        frameworkConfig
-      } = await import('./framework-config.js');
       const timing = frameworkConfig.getTiming();
       this.config = {
         maxRetries: this.options.maxRetries || timing.retryAttempts,

package/dist/lib/shared/utils/framework-config.js

@@ -0,0 +1,567 @@
+/**
+ * Enhanced Configuration Manager
+ * Centralized configuration loading and management for the Clodo Framework
+ * 
+ * Replaces hardcoded values throughout the codebase with configurable settings
+ * from validation-config.json and environment variables
+ */
+
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { FileManager } from './file-manager.js';
+export class FrameworkConfig {
+  constructor(configPath = null) {
+    this.fileManager = new FileManager({
+      enableCache: true
+    });
+    this.configPath = configPath || this.findConfigFile();
+    this.config = this.loadConfig();
+    this.environment = process.env.ENVIRONMENT || 'development';
+
+    // Validate environment variables on initialization
+    this.validateEnvironmentVariables();
+  }
+
+  /**
+   * Find the configuration file in standard locations
+   * 
+   * For a packaged framework, we should only look within the framework's own directory
+   * to maintain self-containment. Users can explicitly pass config paths if needed.
+   */
+  findConfigFile() {
+    let __filename, __dirname;
+
+    // Get the framework's directory (works in both source and packaged environments)
+    try {
+      __filename = fileURLToPath(import.meta.url);
+      __dirname = dirname(__filename);
+    } catch (error) {
+      // Fallback for environments where import.meta is not available
+      // This should not happen in modern Node.js environments
+      console.warn('⚠️  Unable to determine framework directory, using current directory');
+      __dirname = process.cwd();
+    }
+
+    // Only look for config files within the framework's package directory
+    // This ensures the framework is self-contained and doesn't depend on user project files
+    const frameworkRoot = join(__dirname, '..', '..');
+    const possiblePaths = [join(frameworkRoot, 'validation-config.json'), join(frameworkRoot, 'config', 'validation-config.json'),
+    // Allow explicit config path via environment variable (for advanced users)
+    process.env.CLODO_FRAMEWORK_CONFIG && join(process.cwd(), process.env.CLODO_FRAMEWORK_CONFIG)].filter(Boolean); // Remove falsy values
+
+    for (const path of possiblePaths) {
+      if (this.fileManager.exists(path)) {
+        return path;
+      }
+    }
+
+    // Return null instead of throwing - will use default config
+    // This is expected behavior - services don't need their own config
+    return null;
+  }
+
+  /**
+   * Load and parse the configuration file
+   */
+  loadConfig() {
+    // If no config file found, return default configuration
+    // This is normal - services use framework defaults unless they need custom settings
+    if (!this.configPath) {
+      return this.getDefaultConfig();
+    }
+    try {
+      const configContent = this.fileManager.readFile(this.configPath, 'utf8');
+      const config = JSON.parse(configContent);
+      console.log(`📋 Loaded configuration from: ${this.configPath}`);
+      return config;
+    } catch (error) {
+      console.warn(`⚠️  Failed to load configuration from ${this.configPath}: ${error.message}`);
+      console.log('📋 Falling back to default configuration');
+      return this.getDefaultConfig();
+    }
+  }
+
+  /**
+   * Get default configuration when validation-config.json is not available
+   */
+  getDefaultConfig() {
+    return {
+      // Timing configuration (all in milliseconds)
+      deploymentTimeout: 30000,
+      retryAttempts: 3,
+      retryDelay: 1000,
+      connectionTimeout: 5000,
+      heartbeatInterval: 5000,
+      shutdownTimeout: 10000,
+      backupTimeout: 15000,
+      restoreTimeout: 20000,
+      migrationTimeout: 25000,
+      validationTimeout: 8000,
+      rollbackTimeout: 12000,
+      healthCheckInterval: 30000,
+      auditInterval: 60000,
+      cleanupInterval: 300000,
+      monitoringInterval: 15000,
+      alertThrottle: 5000,
+      // Network configuration
+      networking: {
+        maxConcurrentConnections: 10,
+        connectionPoolSize: 5,
+        requestTimeout: 30000,
+        maxRetries: 3,
+        retryDelay: 1000
+      },
+      // Database configuration
+      database: {
+        connectionTimeout: 10000,
+        queryTimeout: 30000,
+        transactionTimeout: 60000,
+        poolMin: 2,
+        poolMax: 10,
+        acquireTimeoutMillis: 60000,
+        createTimeoutMillis: 30000,
+        destroyTimeoutMillis: 5000,
+        idleTimeoutMillis: 30000,
+        reapIntervalMillis: 1000,
+        createRetryIntervalMillis: 200
+      },
+      // Environment configuration
+      environments: {
+        development: {
+          logLevel: 'debug',
+          debugMode: true,
+          dryRun: false
+        },
+        staging: {
+          logLevel: 'info',
+          debugMode: false,
+          dryRun: false
+        },
+        production: {
+          logLevel: 'warn',
+          debugMode: false,
+          dryRun: false
+        }
+      },
+      // Path configuration - all generated files go under generated/
+      paths: {
+        // Base generated directory
+        generated: process.env.FRAMEWORK_GENERATED_DIR || 'generated',
+        // Specific generated subdirectories
+        logs: process.env.FRAMEWORK_LOGS_DIR || 'generated/logs',
+        auditLogs: process.env.FRAMEWORK_AUDIT_DIR || 'generated/audit/logs',
+        backups: process.env.FRAMEWORK_BACKUP_DIR || 'generated/backups',
+        configCache: process.env.FRAMEWORK_CONFIG_CACHE_DIR || 'generated/cache/config',
+        secureTokens: process.env.FRAMEWORK_TOKEN_DIR || 'generated/cache/tokens',
+        auditReports: process.env.FRAMEWORK_REPORTS_DIR || 'generated/audit/reports',
+        testResults: process.env.FRAMEWORK_TEST_RESULTS_DIR || 'generated/test-results',
+        services: process.env.FRAMEWORK_SERVICES_DIR || 'generated/services',
+        temp: process.env.FRAMEWORK_TEMP_DIR || 'generated/temp'
+      }
+    };
+  }
+
+  /**
+   * Reload the configuration from file (useful for testing)
+   */
+  reload() {
+    this.config = this.loadConfig();
+  }
+
+  /**
+   * Get timing configuration with environment variable overrides
+   */
+  getTiming() {
+    const timing = this.config.timing || {};
+    return {
+      deploymentTimeout: parseInt(process.env.DEPLOYMENT_TIMEOUT) || timing.deploymentTimeout || 300000,
+      discoveryTimeout: parseInt(process.env.DISCOVERY_TIMEOUT) || timing.discoveryTimeout || 30000,
+      healthCheckTimeout: parseInt(process.env.HEALTH_CHECK_TIMEOUT) || timing.healthCheckTimeout || 10000,
+      productionTestTimeout: parseInt(process.env.PRODUCTION_TEST_TIMEOUT) || timing.productionTestTimeout || 30000,
+      shutdownTimeout: parseInt(process.env.SHUTDOWN_TIMEOUT) || timing.shutdownTimeout || 30000,
+      forceShutdownTimeout: parseInt(process.env.FORCE_SHUTDOWN_TIMEOUT) || timing.forceShutdownTimeout || 5000,
+      retryDelay: parseInt(process.env.RETRY_DELAY) || timing.retryDelay || 1000,
+      retryAttempts: parseInt(process.env.RETRY_ATTEMPTS) || timing.retryAttempts || 3,
+      cacheTTL: parseInt(process.env.CACHE_TTL) || timing.cacheTTL || 3600000,
+      maxAge: parseInt(process.env.MAX_AGE) || timing.maxAge || 86400000,
+      rateLimitWindow: parseInt(process.env.RATE_LIMIT_WINDOW) || timing.rateLimitWindow || 60000,
+      circuitBreakerTimeout: parseInt(process.env.CIRCUIT_BREAKER_TIMEOUT) || timing.circuitBreakerTimeout || 60000,
+      circuitBreakerThreshold: parseInt(process.env.CIRCUIT_BREAKER_THRESHOLD) || timing.circuitBreakerThreshold || 5,
+      deploymentInterval: parseInt(process.env.DEPLOYMENT_INTERVAL) || timing.deploymentInterval || 5000,
+      endpointValidationTimeout: parseInt(process.env.ENDPOINT_VALIDATION_TIMEOUT) || timing.endpointValidationTimeout || 5000,
+      maxConcurrentDeployments: parseInt(process.env.MAX_CONCURRENT_DEPLOYMENTS) || timing.maxConcurrentDeployments || 3
+    };
+  }
+
+  /**
+   * Get networking configuration
+   */
+  getNetworking() {
+    const networking = this.config.networking || {};
+    return {
+      endpoints: networking.endpoints || {},
+      development: networking.development || {},
+      rateLimiting: {
+        defaultRequests: parseInt(process.env.RATE_LIMIT_REQUESTS) || networking.rateLimiting?.defaultRequests || 100,
+        defaultWindow: parseInt(process.env.RATE_LIMIT_WINDOW_MS) || networking.rateLimiting?.defaultWindow || 60000,
+        burstLimit: parseInt(process.env.RATE_LIMIT_BURST) || networking.rateLimiting?.burstLimit || 200,
+        strictMode: process.env.RATE_LIMIT_STRICT === 'true' || networking.rateLimiting?.strictMode || false
+      }
+    };
+  }
+
+  /**
+   * Get database naming configuration
+   */
+  getDatabaseConfig() {
+    const database = this.config.database || {};
+    const naming = database.namingConvention || {};
+    return {
+      naming: {
+        development: naming.development || '{service}-dev',
+        staging: naming.staging || '{service}-staging',
+        production: naming.production || '{service}'
+      },
+      migration: database.migration || {},
+      connection: {
+        timeout: parseInt(process.env.DB_TIMEOUT) || database.connection?.timeout || 30000,
+        retryAttempts: parseInt(process.env.DB_RETRY_ATTEMPTS) || database.connection?.retryAttempts || 3,
+        poolSize: parseInt(process.env.DB_POOL_SIZE) || database.connection?.poolSize || 10
+      }
+    };
+  }
+
+  /**
+   * Get development ports configuration
+   */
+  getDevelopmentPorts() {
+    const networking = this.config.networking || {};
+    const development = networking.development || {};
+    const defaultPorts = development.defaultPorts || {};
+    return {
+      frontend: parseInt(process.env.FRONTEND_PORT) || defaultPorts.frontend || 3000,
+      api: parseInt(process.env.API_PORT) || defaultPorts.api || 8787,
+      worker: parseInt(process.env.WORKER_PORT) || defaultPorts.worker || 8787,
+      preview: parseInt(process.env.PREVIEW_PORT) || defaultPorts.preview || 8788
+    };
+  }
+
+  /**
+   * Get caching configuration
+   */
+  getCaching() {
+    const caching = this.config.caching || {};
+    return {
+      maxCacheSize: parseInt(process.env.MAX_CACHE_SIZE) || caching.maxCacheSize || 52428800,
+      compressionThreshold: parseInt(process.env.COMPRESSION_THRESHOLD) || caching.compressionThreshold || 1024,
+      cleanupInterval: parseInt(process.env.CLEANUP_INTERVAL) || caching.cleanupInterval || 3600000,
+      enableCompression: process.env.ENABLE_COMPRESSION === 'true' || caching.enableCompression || true,
+      maxEntries: parseInt(process.env.MAX_CACHE_ENTRIES) || caching.maxEntries || 1000
+    };
+  }
+
+  /**
+   * Get monitoring configuration
+   */
+  getMonitoring() {
+    const monitoring = this.config.monitoring || {};
+    return {
+      healthCheck: monitoring.healthCheck || {},
+      metrics: monitoring.metrics || {},
+      logging: monitoring.logging || {}
+    };
+  }
+
+  /**
+   * Get security configuration
+   */
+  getSecurity() {
+    const security = this.config.security || {};
+    return {
+      requiredEnvironmentVars: security.requiredEnvironmentVars || [],
+      optionalEnvironmentVars: security.optionalEnvironmentVars || [],
+      secretsConfig: security.secretsConfig || {}
+    };
+  }
+
+  /**
+   * Get path configuration with environment variable overrides
+   * All generated files are organized under the generated/ folder by default
+   */
+  getPaths() {
+    const paths = this.config.paths || {};
+    return {
+      // Base generated directory
+      generated: process.env.FRAMEWORK_GENERATED_DIR || paths.generated || 'generated',
+      // Specific generated subdirectories
+      logs: process.env.FRAMEWORK_LOGS_DIR || paths.logs || 'generated/logs',
+      auditLogs: process.env.FRAMEWORK_AUDIT_DIR || paths.auditLogs || 'generated/audit/logs',
+      backups: process.env.FRAMEWORK_BACKUP_DIR || paths.backups || 'generated/backups',
+      configCache: process.env.FRAMEWORK_CONFIG_CACHE_DIR || paths.configCache || 'generated/cache/config',
+      secureTokens: process.env.FRAMEWORK_TOKEN_DIR || paths.secureTokens || 'generated/cache/tokens',
+      auditReports: process.env.FRAMEWORK_REPORTS_DIR || paths.auditReports || 'generated/audit/reports',
+      testResults: process.env.FRAMEWORK_TEST_RESULTS_DIR || paths.testResults || 'generated/test-results',
+      services: process.env.FRAMEWORK_SERVICES_DIR || paths.services || 'generated/services',
+      temp: process.env.FRAMEWORK_TEMP_DIR || paths.temp || 'generated/temp'
+    };
+  }
+
+  /**
+   * Get a clean command for removing all generated files
+   */
+  getCleanupCommand() {
+    const paths = this.getPaths();
+    return `rm -rf ${paths.generated}`;
+  }
+
+  /**
+   * Get environment configuration with validation
+   */
+  getEnvironmentConfig(environment = null) {
+    const env = environment || this.environment;
+    const environments = this.config.environments || {};
+    const envConfig = environments[env] || environments.development || {};
+    if (!envConfig || Object.keys(envConfig).length === 0) {
+      console.warn(`⚠️  No configuration found for environment: ${env}. Using development defaults.`);
+      return {
+        domainTemplate: process.env.DOMAIN_TEMPLATE || '{service}.{domain}',
+        workerSuffix: process.env.WORKER_SUFFIX || '',
+        databaseSuffix: process.env.DATABASE_SUFFIX || '',
+        logLevel: this.validateLogLevel(process.env.LOG_LEVEL) || 'info',
+        enableMetrics: process.env.ENABLE_METRICS === 'true' || true,
+        strictValidation: process.env.STRICT_VALIDATION === 'true' || false,
+        debugMode: env === 'development',
+        dryRun: false
+      };
+    }
+    return {
+      domainTemplate: process.env.DOMAIN_TEMPLATE || envConfig.domainTemplate || '{service}.{domain}',
+      workerSuffix: process.env.WORKER_SUFFIX || envConfig.workerSuffix || '',
+      databaseSuffix: process.env.DATABASE_SUFFIX || envConfig.databaseSuffix || '',
+      logLevel: this.validateLogLevel(process.env.LOG_LEVEL) || this.validateLogLevel(envConfig.logLevel) || 'info',
+      enableMetrics: process.env.ENABLE_METRICS === 'true' || envConfig.enableMetrics || true,
+      strictValidation: process.env.STRICT_VALIDATION === 'true' || envConfig.strictValidation || false,
+      debugMode: envConfig.debugMode || false,
+      dryRun: envConfig.dryRun || false
+    };
+  }
+
+  /**
+   * Validate LOG_LEVEL environment variable
+   */
+  validateLogLevel(level) {
+    const validLevels = ['error', 'warn', 'info', 'debug', 'trace'];
+    if (!level) return null;
+    const normalizedLevel = level.toLowerCase();
+    if (!validLevels.includes(normalizedLevel)) {
+      console.warn(`⚠️  Invalid LOG_LEVEL "${level}". Valid values: ${validLevels.join(', ')}. Using 'info'.`);
+      return 'info';
+    }
+    return normalizedLevel;
+  }
+
+  /**
+   * Validate required environment variables
+   */
+  validateEnvironmentVariables() {
+    const errors = [];
+    const warnings = [];
+
+    // Validate LOG_LEVEL if present
+    if (process.env.LOG_LEVEL) {
+      this.validateLogLevel(process.env.LOG_LEVEL);
+    }
+
+    // Validate ENVIRONMENT if present
+    if (process.env.ENVIRONMENT) {
+      const validEnvironments = ['development', 'staging', 'production'];
+      if (!validEnvironments.includes(process.env.ENVIRONMENT)) {
+        warnings.push(`Invalid ENVIRONMENT "${process.env.ENVIRONMENT}". Valid values: ${validEnvironments.join(', ')}`);
+      }
+    }
+
+    // Validate framework-specific environment variables
+    const frameworkEnvVars = ['FRAMEWORK_LOGS_DIR', 'FRAMEWORK_AUDIT_DIR', 'FRAMEWORK_BACKUP_DIR', 'FRAMEWORK_CONFIG_CACHE_DIR', 'FRAMEWORK_TOKEN_DIR', 'FRAMEWORK_REPORTS_DIR'];
+    frameworkEnvVars.forEach(varName => {
+      if (process.env[varName]) {
+        // Validate path doesn't contain dangerous characters
+        const value = process.env[varName];
+        if (value.includes('..') || value.includes('~')) {
+          warnings.push(`Environment variable ${varName} contains potentially dangerous path: ${value}`);
+        }
+      }
+    });
+
+    // Log validation results
+    if (warnings.length > 0) {
+      console.warn('⚠️  Environment variable validation warnings:');
+      warnings.forEach(warning => console.warn(`   - ${warning}`));
+    }
+    if (errors.length > 0) {
+      console.error('❌ Environment variable validation errors:');
+      errors.forEach(error => console.error(`   - ${error}`));
+      throw new Error('Environment variable validation failed');
+    }
+    if (warnings.length === 0 && errors.length === 0) {
+      console.log('✅ Environment variables validated successfully');
+    }
+    return {
+      errors,
+      warnings
+    };
+  }
+
+  /**
+   * Get testing configuration
+   */
+  getTesting() {
+    const testing = this.config.testing || {};
+    return {
+      production: {
+        enabled: process.env.PRODUCTION_TESTS === 'true' || testing.production?.enabled || true,
+        lightweight: process.env.LIGHTWEIGHT_TESTS === 'true' || testing.production?.lightweight || true,
+        skipHeavyTests: process.env.SKIP_HEAVY_TESTS === 'true' || testing.production?.skipHeavyTests || true,
+        generateReports: process.env.GENERATE_REPORTS === 'true' || testing.production?.generateReports || false,
+        testTimeout: parseInt(process.env.TEST_TIMEOUT) || testing.production?.testTimeout || 30000
+      },
+      integration: testing.integration || {}
+    };
+  }
+
+  /**
+   * Generate database name based on service and environment
+   */
+  generateDatabaseName(serviceName, environment = this.environment) {
+    const dbConfig = this.getDatabaseConfig();
+    const template = dbConfig.naming[environment] || dbConfig.naming.production || '{service}';
+    return template.replace('{service}', serviceName);
+  }
+
+  /**
+   * Generate development URLs based on service and configuration
+   */
+  generateDevelopmentUrls(serviceName) {
+    const ports = this.getDevelopmentPorts();
+    return {
+      frontend: `http://localhost:${ports.frontend}`,
+      api: `http://localhost:${ports.api}`,
+      worker: `http://localhost:${ports.worker}`,
+      preview: `http://localhost:${ports.preview}`
+    };
+  }
+
+  /**
+   * Validate environment variables
+   */
+  validateEnvironment() {
+    const security = this.getSecurity();
+    const missing = [];
+    for (const envVar of security.requiredEnvironmentVars) {
+      if (!process.env[envVar]) {
+        missing.push(envVar);
+      }
+    }
+    if (missing.length > 0) {
+      throw new Error(`Missing required environment variables: ${missing.join(', ')}`);
+    }
+    return true;
+  }
+
+  /**
+   * Get routing configuration
+   * Provides route generation settings from validation-config.json
+   */
+  getRoutingConfig() {
+    const routing = this.config.routing || {};
+    const templates = this.config.templates || {};
+    const workersDomain = templates.defaults?.WORKERS_DEV_DOMAIN || 'workers.dev';
+    return {
+      defaults: {
+        includeComments: routing.defaults?.includeComments !== false,
+        includeZoneId: routing.defaults?.includeZoneId !== false,
+        targetEnvironment: routing.defaults?.targetEnvironment || 'all',
+        orderStrategy: routing.defaults?.orderStrategy || 'most-specific-first'
+      },
+      domains: {
+        skipPatterns: routing.domains?.skipPatterns || [],
+        workersDomain,
+        // Reuse from templates.defaults.WORKERS_DEV_DOMAIN
+        complexTLDs: routing.domains?.complexTLDs || ['.co.uk', '.com.au', '.org.uk', '.gov.uk'],
+        subdomainMinParts: routing.domains?.subdomainMinParts || 3,
+        ignoreSubdomains: routing.domains?.ignoreSubdomains || ['www']
+      },
+      validation: {
+        zoneIdPattern: routing.validation?.zoneIdPattern || '^[a-f0-9]{32}$',
+        domainPattern: routing.validation?.domainPattern || '^[a-z0-9.-]+$',
+        strictMode: routing.validation?.strictMode !== false
+      },
+      comments: {
+        enabled: routing.comments?.enabled !== false,
+        templates: routing.comments?.templates || {
+          production: '# Production environment routes\n# Domain: {{domain}}',
+          staging: '# Staging environment routes\n# Domain: {{domain}}',
+          development: '# Development environment\n# Uses {{WORKERS_DEV_DOMAIN}} subdomain'
+        }
+      }
+    };
+  }
+
+  /**
+   * Get environment-specific routing configuration
+   * Combines global routing config with environment-specific settings
+   */
+  getEnvironmentRoutingConfig(environment = null) {
+    const env = environment || this.environment;
+    const environments = this.config.environments || {};
+    const envConfig = environments[env] || environments.development || {};
+    const routingConfig = envConfig.routing || {};
+
+    // Fallback defaults if not in config
+    const defaultPrefixes = {
+      development: '/dev-api',
+      staging: '/staging-api',
+      production: '/api'
+    };
+    return {
+      defaultPathPrefix: routingConfig.defaultPathPrefix || defaultPrefixes[env] || '/api',
+      wildcardPattern: routingConfig.wildcardPattern || '/*',
+      generateFallbackRoute: routingConfig.generateFallbackRoute !== false,
+      nestedInToml: env !== 'production' && routingConfig.nestedInToml !== false
+    };
+  }
+
+  /**
+   * Get all environment names from config
+   */
+  getEnvironmentNames() {
+    const environments = this.config.environments || {};
+    return Object.keys(environments).length > 0 ? Object.keys(environments) : ['development', 'staging', 'production'];
+  }
+
+  /**
+   * Get aggregated configuration for all needs
+   */
+  getAll() {
+    return {
+      timing: this.getTiming(),
+      networking: this.getNetworking(),
+      environment: this.getEnvironmentConfig(),
+      database: this.getDatabaseConfig(),
+      ports: this.getDevelopmentPorts(),
+      caching: this.getCaching(),
+      monitoring: this.getMonitoring(),
+      security: this.getSecurity(),
+      testing: this.getTesting(),
+      routing: this.getRoutingConfig()
+    };
+  }
+}
+
+// Export singleton instance for easy access
+export const frameworkConfig = new FrameworkConfig();
+
+// Export utility functions
+export const getFrameworkConfig = (configPath = null) => {
+  return configPath ? new FrameworkConfig(configPath) : frameworkConfig;
+};
+export default FrameworkConfig;

package/dist/lib/shared/utils/graceful-shutdown-manager.js

@@ -3,6 +3,7 @@
  * Implements SIGTERM/SIGINT handlers and cleanup routines for CLI tools
  */
 
+import { frameworkConfig } from './framework-config.js';
 export class GracefulShutdownManager {
   constructor(options = {}) {
     this.options = options;
@@ -17,10 +18,7 @@ export class GracefulShutdownManager {
    * Initialize with framework configuration
    */
   async initialize() {
-    // Import framework config for consistent timing settings
-    const {
-      frameworkConfig
-    } = await import('../../utils/framework-config.js');
+    // Use framework config for consistent timing settings
     const timing = frameworkConfig.getTiming();
     this.config = {
       shutdownTimeout: this.options.shutdownTimeout || timing.shutdownTimeout,

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

@@ -28,4 +28,7 @@ export { validateDeploymentPrerequisites, validateDeploymentInputs } from './dep
 export { redactSensitiveInfo, redactSensitiveObject } from './sensitive-redactor.js';
 
 // Configuration loading
-export { ConfigLoader } from './config-loader.js';
+export { ConfigLoader } from './config-loader.js';
+
+// Framework configuration
+export { FrameworkConfig, frameworkConfig, getFrameworkConfig } from './framework-config.js';

package/dist/security/index.js

@@ -6,11 +6,13 @@
 import { ConfigurationValidator } from './ConfigurationValidator.js';
 // DeploymentManager removed - replaced by MultiDomainOrchestrator + WranglerConfigManager
 import { SecretGenerator } from './SecretGenerator.js';
+import { SecurityCLI } from './SecurityCLI.js';
 // InteractiveDeploymentConfigurator removed - replaced by InputCollector
 
 export { ConfigurationValidator } from './ConfigurationValidator.js';
-// export { DeploymentManager } - DEPRECATED: Use MultiDomainOrchestrator instead
+// export { DeploymentManager} - DEPRECATED: Use MultiDomainOrchestrator instead
 export { SecretGenerator } from './SecretGenerator.js';
+export { SecurityCLI } from './SecurityCLI.js';
 // export { InteractiveDeploymentConfigurator } - DEPRECATED: Use InputCollector instead
 
 // Re-export patterns and rules for advanced usage

package/dist/service-management/handlers/ValidationHandler.js

@@ -5,12 +5,49 @@
 
 import fs from 'fs/promises';
 import path from 'path';
+import { FrameworkConfig } from '../../utils/framework-config.js';
 export class ValidationHandler {
   constructor(options = {}) {
     this.strict = options.strict || false;
     this.customConfig = options.customConfig || {};
+    this.configLoaded = false;
+  }
+
+  /**
+   * Load validation configuration from validation-config.json if it exists
+   */
+  loadValidationConfig(servicePath) {
+    // Skip if already loaded or custom config provided
+    if (this.configLoaded || Object.keys(this.customConfig).length > 0) {
+      return this.validationConfig;
+    }
+    try {
+      // Try to load validation-config.json from service directory
+      const configPath = path.join(servicePath, 'validation-config.json');
+      const frameworkConfig = new FrameworkConfig(configPath);
+      const config = frameworkConfig.config;
+
+      // Extract validation section from config
+      if (config && config.validation) {
+        // Log that we loaded the config
+        console.log(`📋 Loaded configuration from: ${configPath}`);
+        this.validationConfig = {
+          requiredFiles: config.validation.requiredFiles || ['package.json', 'src/config/domains.js', 'src/worker/index.js', 'wrangler.toml'],
+          optionalFiles: config.validation.optionalFiles || ['README.md', 'LICENSE', '.gitignore'],
+          requiredFields: config.validation.requiredFields || {
+            'package.json': ['name', 'version', 'type', 'main'],
+            'wrangler.toml': ['name', 'main', 'compatibility_date']
+          },
+          serviceTypes: config.validation.serviceTypes || ['data-service', 'auth-service', 'content-service', 'api-gateway', 'static-site', 'generic']
+        };
+        this.configLoaded = true;
+        return this.validationConfig;
+      }
+    } catch (error) {
+      // Config loading failed, use defaults silently
+    }
 
-    // Use custom validation config if provided, otherwise use defaults
+    // Use custom config if provided, otherwise use defaults
     this.validationConfig = {
       requiredFiles: this.customConfig.requiredFiles || ['package.json', 'src/config/domains.js', 'src/worker/index.js', 'wrangler.toml'],
       optionalFiles: this.customConfig.optionalFiles || ['README.md', 'LICENSE', '.gitignore'],
@@ -20,12 +57,16 @@ export class ValidationHandler {
       },
       serviceTypes: this.customConfig.serviceTypes || ['data-service', 'auth-service', 'content-service', 'api-gateway', 'static-site', 'generic']
     };
+    this.configLoaded = true;
+    return this.validationConfig;
   }
 
   /**
    * Validate complete service configuration
    */
   async validateService(servicePath) {
+    // Load validation config from validation-config.json if it exists
+    this.loadValidationConfig(servicePath);
     const issues = [];
 
     // Check for required files using custom config

package/dist/service-management/routing/DomainRouteMapper.js

@@ -7,7 +7,7 @@
  * @module service-management/routing/DomainRouteMapper
  */
 
-import { frameworkConfig } from '../../utils/framework-config.js';
+import { frameworkConfig } from '../../lib/shared/utils/framework-config.js';
 export class DomainRouteMapper {
   constructor(options = {}) {
     // Load environment-specific routing config

package/dist/service-management/routing/RouteGenerator.js

@@ -9,7 +9,7 @@
 
 import { DomainRouteMapper } from './DomainRouteMapper.js';
 import { WranglerRoutesBuilder } from './WranglerRoutesBuilder.js';
-import { frameworkConfig } from '../../utils/framework-config.js';
+import { frameworkConfig } from '../../lib/shared/utils/framework-config.js';
 export class RouteGenerator {
   constructor(options = {}) {
     this.mapper = new DomainRouteMapper(options);

package/dist/utils/deployment/config-cache.js

@@ -21,7 +21,7 @@ import { access, readFile, writeFile, mkdir, readdir, stat } from 'fs/promises';
 import { join, dirname } from 'path';
 import { promisify } from 'util';
 import { exec } from 'child_process';
-import { frameworkConfig } from '../framework-config.js';
+import { frameworkConfig } from '../../lib/shared/utils/framework-config.js';
 import { NameFormatters } from '../formatters.js';
 const execAsync = promisify(exec);
 export class ConfigurationCacheManager {

package/dist/utils/deployment/index.js

@@ -5,4 +5,4 @@ export { ConfigurationCacheManager } from './config-cache.js';
 export { EnhancedSecretManager } from './secret-generator.js';
 export { UnifiedConfigManager, unifiedConfigManager } from '../config/unified-config-manager.js';
 export { askUser, askYesNo, askChoice, closePrompts } from '../interactive-prompts.js';
-export { DeploymentCredentialCollector } from '../../../lib/shared/deployment/credential-collector.js';
+export { DeploymentCredentialCollector } from '../../lib/shared/deployment/credential-collector.js';

package/dist/utils/framework-config.js

@@ -1,10 +1,10 @@
 /**
- * Enhanced Configuration Manager
- * Centralized configuration loading and management for the Clodo Framework
- * 
- * Replaces hardcoded values throughout the codebase with configurable settings
- * from validation-config.json and environment variables
- */
+* Enhanced Configuration Manager
+* Centralized configuration loading and management for the Clodo Framework
+* 
+* Replaces hardcoded values throughout the codebase with configurable settings
+* from validation-config.json and environment variables
+*/
 
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';

package/dist/utils/graceful-shutdown-manager.js

@@ -17,10 +17,10 @@ export class GracefulShutdownManager {
    * Initialize with framework configuration
    */
   async initialize() {
-    // Import framework config for consistent timing
+    // Import framework config for consistent timing settings
     const {
       frameworkConfig
-    } = await import('./framework-config.js');
+    } = await import('../lib/shared/utils/framework-config.js');
     const timing = frameworkConfig.getTiming();
     this.config = {
       shutdownTimeout: this.options.shutdownTimeout || timing.shutdownTimeout,

package/dist/utils/index.js

@@ -35,8 +35,8 @@ export * from './validation.js';
 // Health checking utilities
 export * from './health-checker.js';
 
-// Framework configuration
-export * from './framework-config.js';
+// Framework configuration - re-export from canonical location
+export { FrameworkConfig, frameworkConfig, getFrameworkConfig } from '../lib/shared/utils/framework-config.js';
 
 // Deployment utilities
 export * from './deployment/index.js';

package/dist/worker/features.js

@@ -0,0 +1,43 @@
+/**
+ * Common Feature Constants
+ * Worker-safe constants extracted from ConfigurationManager
+ * No Node.js dependencies (fs, path, etc.)
+ */
+
+export const COMMON_FEATURES = {
+  // Schema Manager Features
+  ENABLE_ENHANCED_SCHEMA: true,
+  ENABLE_SCHEMA_CACHING: true,
+  ENABLE_COMPREHENSIVE_VALIDATION: true,
+  ENABLE_SQL_CACHING: true,
+  // Generic Data Service Features
+  ENABLE_QUERY_CACHING: true,
+  ENABLE_SECURITY_CONTROLS: true,
+  ENABLE_ADVANCED_PAGINATION: true,
+  ENABLE_RELATIONSHIP_LOADING: true,
+  // Module Manager Features
+  ENABLE_ENHANCED_HOOKS: true,
+  ENABLE_HOOK_TIMEOUT: true,
+  ENABLE_HOOK_METRICS: true,
+  ENABLE_PARALLEL_EXECUTION: true,
+  // Performance Features
+  ENABLE_PERFORMANCE_MONITORING: true,
+  ENABLE_CACHE_METRICS: true,
+  ENABLE_QUERY_OPTIMIZATION: true,
+  // Development Features
+  ENABLE_DEBUG_LOGGING: false,
+  ENABLE_DEVELOPMENT_MODE: false,
+  ENABLE_STRICT_VALIDATION: false,
+  // Migration Features
+  ENABLE_LEGACY_COMPATIBILITY: true,
+  ENABLE_DEPRECATION_WARNINGS: true,
+  ENABLE_MIGRATION_HELPERS: true,
+  // Domain-specific features
+  AUTHENTICATION: true,
+  AUTHORIZATION: true,
+  LOGGING: true,
+  MONITORING: true,
+  CACHING: true,
+  RATE_LIMITING: true,
+  FILE_STORAGE: true
+};

package/dist/worker/integration.js

@@ -1,13 +1,13 @@
 import { getDomainFromEnv, createEnvironmentConfig } from '../config/domains.js';
 
-// Import COMMON_FEATURES from ConfigurationManager
-import { COMMON_FEATURES } from '../../lib/shared/config/ConfigurationManager.js';
+// Import COMMON_FEATURES from worker-safe constants (no Node.js dependencies)
+import { COMMON_FEATURES } from './features.js';
 
 // Simple feature manager interface (replaces ConfigurationManager dependency)
 export const configManager = {
   setDomain: () => {},
-  getEnabledFeatures: () => Object.values(COMMON_FEATURES),
-  isFeatureEnabled: feature => Object.values(COMMON_FEATURES).includes(feature)
+  getEnabledFeatures: () => Object.keys(COMMON_FEATURES).filter(key => COMMON_FEATURES[key]),
+  isFeatureEnabled: feature => COMMON_FEATURES[feature] === true
 };
 
 // Legacy featureManager compatibility interface
@@ -185,7 +185,7 @@ export const createRateLimitGuard = (options = {}) => {
   return handler => {
     return async (request, env, ctx) => {
       // Skip rate limiting if feature is disabled
-      if (!featureManager.isEnabled(COMMON_FEATURES.RATE_LIMITING)) {
+      if (!featureManager.isEnabled('RATE_LIMITING')) {
         return handler(request, env, ctx);
       }
       const clientId = request.headers.get('CF-Connecting-IP') || 'anonymous';

package/dist/worker-entry.js

@@ -0,0 +1,28 @@
+/**
+ * Worker Entry Point
+ * Minimal exports for Cloudflare Workers - excludes CLI/Node.js dependencies
+ * 
+ * This is the entry point for wrangler.toml
+ * Only exports worker-compatible code (no fs, path, child_process, etc.)
+ */
+
+// Worker integration (no Node.js dependencies)
+export { initializeService, configManager } from './worker/integration.js';
+
+// Domain configuration (pure JS, no fs dependencies)
+export { getDomainFromEnv, createEnvironmentConfig } from './config/domains.js';
+
+// Framework version
+export const FRAMEWORK_VERSION = '1.0.0';
+
+// Default export for module worker format
+export default {
+  async fetch(request, env, ctx) {
+    return new Response('Clodo Framework Worker - Use initializeService() to set up your worker', {
+      status: 200,
+      headers: {
+        'content-type': 'text/plain'
+      }
+    });
+  }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tamyla/clodo-framework",
-  "version": "3.2.5",
+  "version": "4.0.0",
   "description": "Reusable framework for Clodo-style software architecture on Cloudflare Workers + D1",
   "type": "module",
   "sideEffects": [
@@ -88,6 +88,8 @@
     "test:worker": "cross-env NODE_OPTIONS=--experimental-vm-modules jest test/worker/ --verbose",
     "test:integration": "cross-env NODE_OPTIONS=--experimental-vm-modules jest test/integration/ --verbose",
     "test:comprehensive": "cross-env NODE_OPTIONS=--experimental-vm-modules jest test/comprehensive-suite.spec.js --verbose",
+    "test:package": "node scripts/test-package.js",
+    "prepublishOnly": "npm run build:ci",
     "test:coverage:cli": "cross-env NODE_OPTIONS=--experimental-vm-modules jest test/cli-integration/ --coverage",
     "test:coverage:deployment": "cross-env NODE_OPTIONS=--experimental-vm-modules jest test/deployment/ test/deployment-security.spec.js --coverage",
     "test:coverage:services": "cross-env NODE_OPTIONS=--experimental-vm-modules jest test/service-management/ test/services/ --coverage",
@@ -101,7 +103,6 @@
     "analyze:bundle": "echo 'Bundle analysis not implemented yet'",
     "docs": "echo 'JSDoc documentation generation not configured yet'",
     "validate": "npm run check:all",
-    "prepublishOnly": "npm run build:ci",
     "postpublish": "echo 'Published successfully to npm registry!'",
     "publish:beta": "npm publish --tag beta",
     "publish:latest": "npm publish --tag latest",