@tamyla/clodo-framework 3.2.0 → 3.2.1

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [3.2.1](https://github.com/tamylaa/clodo-framework/compare/v3.2.0...v3.2.1) (2025-12-05)
+
+
+### Bug Fixes
+
+* enhance deploy command with prerequisite checking and organize project structure ([660c5ab](https://github.com/tamylaa/clodo-framework/commit/660c5ab82546ca1a80b42c1d4cbc6d3972cc6203))
+
 # [3.2.0](https://github.com/tamylaa/clodo-framework/compare/v3.1.27...v3.2.0) (2025-12-03)
 
 

package/dist/cli/commands/deploy.js

@@ -2,10 +2,11 @@ import chalk from 'chalk';
 import { Clodo } from '@tamyla/clodo-framework';
 import { StandardOptions } from '../../lib/shared/utils/cli-options.js';
 import { ConfigLoader } from '../../lib/shared/utils/config-loader.js';
+import { InteractiveDeploymentCoordinator } from '../../lib/shared/deployment/workflows/interactive-deployment-coordinator.js';
 export function registerDeployCommand(program) {
-  const command = program.command('deploy').description('Deploy a Clodo service with smart credential handling and domain selection')
+  const command = program.command('deploy').description('Deploy a Clodo service with interactive configuration and validation')
   // Cloudflare-specific options
-  .option('--token <token>', 'Cloudflare API token').option('--account-id <id>', 'Cloudflare account ID').option('--zone-id <id>', 'Cloudflare zone ID').option('--domain <domain>', 'Specific domain to deploy to (otherwise prompted if multiple exist)').option('--environment <env>', 'Target environment (development, staging, production)', 'production').option('--development', 'Deploy to development environment (shorthand for --environment development)').option('--staging', 'Deploy to staging environment (shorthand for --environment staging)').option('--production', 'Deploy to production environment (shorthand for --environment production)').option('--dry-run', 'Simulate deployment without making changes').option('-y, --yes', 'Skip confirmation prompts (for CI/CD)').option('--service-path <path>', 'Path to service directory', '.');
+  .option('--token <token>', 'Cloudflare API token (or set CLOUDFLARE_API_TOKEN env var)').option('--account-id <id>', 'Cloudflare account ID (or set CLOUDFLARE_ACCOUNT_ID env var)').option('--zone-id <id>', 'Cloudflare zone ID (or set CLOUDFLARE_ZONE_ID env var)').option('--domain <domain>', 'Specific domain to deploy to').option('--environment <env>', 'Target environment (development, staging, production)', 'production').option('--development', 'Deploy to development environment (shorthand for --environment development)').option('--staging', 'Deploy to staging environment (shorthand for --environment staging)').option('--production', 'Deploy to production environment (shorthand for --environment production)').option('--dry-run', 'Simulate deployment without making changes').option('-y, --yes', 'Skip confirmation prompts (for CI/CD)').option('--service-path <path>', 'Path to service directory', '.').option('--check-prereqs', 'Check deployment prerequisites before starting').option('--check-auth', 'Check Wrangler authentication status').option('--check-network', 'Check network connectivity to Cloudflare');
 
   // Add standard options (--verbose, --quiet, --json, --no-color, --config-file)
   StandardOptions.define(command).action(async options => {
@@ -38,26 +39,63 @@ export function registerDeployCommand(program) {
       // Merge config file defaults with CLI options (CLI takes precedence)
       const mergedOptions = configLoader.merge(configFileData, options);
 
-      // Use simple API for deployment
-      const result = await Clodo.deploy({
-        servicePath: mergedOptions.servicePath || '.',
-        environment: mergedOptions.environment || 'production',
-        domain: mergedOptions.domain,
-        dryRun: mergedOptions.dryRun || false,
-        credentials: {
-          token: mergedOptions.token,
-          accountId: mergedOptions.accountId,
-          zoneId: mergedOptions.zoneId
-        }
-      });
-      if (result.success) {
-        output.success(result.message);
-        if (result.deployedDomains && result.deployedDomains.length > 0) {
-          output.info(`Deployed to domains: ${result.deployedDomains.join(', ')}`);
+      // Determine if interactive mode should be enabled
+      const interactive = !mergedOptions.nonInteractive && !mergedOptions.yes;
+      if (interactive) {
+        console.log(chalk.cyan('\n🚀 Interactive Clodo Service Deployment'));
+        console.log(chalk.gray('═'.repeat(60)));
+        console.log(chalk.white('Welcome to the interactive deployment wizard!\n'));
+
+        // Use the interactive deployment coordinator
+        const coordinator = new InteractiveDeploymentCoordinator({
+          servicePath: mergedOptions.servicePath || '.',
+          environment: mergedOptions.environment || 'production',
+          domain: mergedOptions.domain,
+          dryRun: mergedOptions.dryRun || false,
+          credentials: {
+            token: mergedOptions.token,
+            accountId: mergedOptions.accountId,
+            zoneId: mergedOptions.zoneId
+          },
+          checkPrereqs: mergedOptions.checkPrereqs,
+          checkAuth: mergedOptions.checkAuth,
+          checkNetwork: mergedOptions.checkNetwork,
+          verbose: mergedOptions.verbose,
+          quiet: mergedOptions.quiet,
+          json: mergedOptions.json
+        });
+        const result = await coordinator.runInteractiveDeployment();
+        if (result.success) {
+          output.success(result.message);
+          if (result.deployedDomains && result.deployedDomains.length > 0) {
+            output.info(`Deployed to domains: ${result.deployedDomains.join(', ')}`);
+          }
+        } else {
+          output.error('Interactive deployment failed');
+          process.exit(1);
         }
       } else {
-        output.error('Deployment failed');
-        process.exit(1);
+        // Use simple API for deployment (non-interactive/CI mode)
+        const result = await Clodo.deploy({
+          servicePath: mergedOptions.servicePath || '.',
+          environment: mergedOptions.environment || 'production',
+          domain: mergedOptions.domain,
+          dryRun: mergedOptions.dryRun || false,
+          credentials: {
+            token: mergedOptions.token,
+            accountId: mergedOptions.accountId,
+            zoneId: mergedOptions.zoneId
+          }
+        });
+        if (result.success) {
+          output.success(result.message);
+          if (result.deployedDomains && result.deployedDomains.length > 0) {
+            output.info(`Deployed to domains: ${result.deployedDomains.join(', ')}`);
+          }
+        } else {
+          output.error('Deployment failed');
+          process.exit(1);
+        }
       }
     } catch (error) {
       const output = new (await import('../../lib/shared/utils/output-formatter.js')).OutputFormatter(options || {});

package/dist/config/.env.staging.example

@@ -0,0 +1,25 @@
+# Staging Environment Configuration
+# Copy this file to .env.staging and fill in your actual Cloudflare credentials
+# DO NOT commit this file to version control
+
+# Cloudflare API Credentials for Staging Environment
+CLOUDFLARE_API_TOKEN=your_staging_cloudflare_api_token_here
+CLOUDFLARE_ACCOUNT_ID=your_staging_cloudflare_account_id_here
+CLOUDFLARE_ZONE_ID=your_staging_cloudflare_zone_id_here
+
+# Staging Domain Configuration
+STAGING_DOMAIN=staging.example.com
+STAGING_ZONE_ID=${CLOUDFLARE_ZONE_ID}
+
+# Database Configuration (if different from development)
+STAGING_DATABASE_ID=your_staging_database_id_here
+STAGING_DATABASE_NAME=api2-com-staging-db
+
+# Monitoring and Alerting
+STAGING_METRICS_ENDPOINT=https://metrics-staging.example.com
+STAGING_ALERT_EMAIL=staging-alerts@example.com
+
+# Security Settings
+STAGING_WAF_ENABLED=true
+STAGING_RATE_LIMIT=500
+STAGING_CORS_ORIGINS=https://staging.example.com,https://app-staging.example.com

package/dist/deployment/index.js

@@ -1,11 +1,11 @@
 // Deployment Module
 // Core deployment components for the Clodo Framework
 
-export { WranglerDeployer } from './wrangler-deployer.js';
+// NOTE: WranglerDeployer has lib/ dependencies not available in npm distribution
+// export { WranglerDeployer } from './wrangler-deployer.js';
 
 // Orchestration Framework - Public API for downstream consumers
 export { BaseDeploymentOrchestrator } from './orchestration/BaseDeploymentOrchestrator.js';
 export { SingleServiceOrchestrator } from './orchestration/SingleServiceOrchestrator.js';
 export { PortfolioOrchestrator } from './orchestration/PortfolioOrchestrator.js';
-export { EnterpriseOrchestrator } from './orchestration/EnterpriseOrchestrator.js';
 export { UnifiedDeploymentOrchestrator } from './orchestration/UnifiedDeploymentOrchestrator.js';

package/dist/deployment/orchestration/BaseDeploymentOrchestrator.js

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

package/dist/deployment/orchestration/UnifiedDeploymentOrchestrator.js

@@ -36,8 +36,7 @@
 import { BaseDeploymentOrchestrator } from './BaseDeploymentOrchestrator.js';
 import { SingleServiceOrchestrator } from './SingleServiceOrchestrator.js';
 import { PortfolioOrchestrator } from './PortfolioOrchestrator.js';
-import { EnterpriseOrchestrator } from './EnterpriseOrchestrator.js';
-import { ErrorHandler } from '../../shared/utils/ErrorHandler.js';
+import { ErrorHandler } from '../../../lib/shared/utils/ErrorHandler.js';
 
 /**
  * Capability descriptors - Defines what each capability provides
@@ -204,8 +203,7 @@ export class UnifiedDeploymentOrchestrator extends BaseDeploymentOrchestrator {
     // System adapters for backward compatibility
     this.systemAdapters = {
       single: SingleServiceOrchestrator,
-      portfolio: PortfolioOrchestrator,
-      enterprise: EnterpriseOrchestrator
+      portfolio: PortfolioOrchestrator
     };
 
     // Deployment context

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

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

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

@@ -242,7 +242,7 @@ export async function listDatabases(options = {}) {
   if (apiToken && accountId) {
     const {
       CloudflareAPI
-    } = await import('../../../src/utils/cloudflare/api.js');
+    } = await import('@tamyla/clodo-framework/utils/cloudflare');
     const cf = new CloudflareAPI(apiToken);
     return await cf.listD1Databases(accountId);
   }
@@ -267,7 +267,7 @@ export async function databaseExists(databaseName, options = {}) {
   if (apiToken && accountId) {
     const {
       CloudflareAPI
-    } = await import('../../../src/utils/cloudflare/api.js');
+    } = await import('@tamyla/clodo-framework/utils/cloudflare');
     const cf = new CloudflareAPI(apiToken);
     return await cf.d1DatabaseExists(accountId, databaseName);
   }
@@ -290,7 +290,7 @@ export async function createDatabase(name, options = {}) {
   if (apiToken && accountId) {
     const {
       CloudflareAPI
-    } = await import('../../../src/utils/cloudflare/api.js');
+    } = await import('@tamyla/clodo-framework/utils/cloudflare');
     const cf = new CloudflareAPI(apiToken);
     const result = await cf.createD1Database(accountId, name);
     return result.uuid; // Return UUID to match CLI behavior
@@ -405,7 +405,7 @@ export async function getDatabaseId(databaseName, options = {}) {
   if (apiToken && accountId) {
     const {
       CloudflareAPI
-    } = await import('../../../src/utils/cloudflare/api.js');
+    } = await import('@tamyla/clodo-framework/utils/cloudflare');
     const cf = new CloudflareAPI(apiToken);
     const db = await cf.getD1Database(accountId, databaseName);
     return db?.uuid || null;
@@ -430,33 +430,119 @@ export async function getDatabaseId(databaseName, options = {}) {
 }
 
 // Validate prerequisites
-export async function validatePrerequisites() {
+export async function validatePrerequisites(options = {}) {
+  const {
+    checkAuth = false,
+    checkNetwork = false,
+    verbose = false
+  } = options;
   const checks = [{
     name: 'Node.js',
-    command: 'node --version'
+    command: 'node --version',
+    required: true,
+    description: 'Required for running the framework and build processes',
+    minVersion: '18.0.0'
   }, {
     name: 'NPM',
-    command: 'npm --version'
+    command: 'npm --version',
+    required: true,
+    description: 'Required for package management and scripts',
+    minVersion: '8.0.0'
   }, {
     name: 'Wrangler',
-    command: 'npx wrangler --version'
+    command: 'npx wrangler --version',
+    required: true,
+    description: 'Cloudflare CLI for Workers and D1 database management',
+    minVersion: '3.0.0'
   }];
+
+  // Add optional checks
+  if (checkAuth) {
+    checks.push({
+      name: 'Wrangler Auth',
+      command: 'npx wrangler whoami',
+      required: false,
+      description: 'Cloudflare authentication (optional - can authenticate during deployment)',
+      async: true
+    });
+  }
+  if (checkNetwork) {
+    checks.push({
+      name: 'Network',
+      command: null,
+      required: false,
+      description: 'Internet connectivity to Cloudflare API',
+      async: true,
+      checkFunction: async () => {
+        try {
+          const response = await fetch('https://api.cloudflare.com/client/v4/user/tokens/verify', {
+            method: 'GET',
+            headers: {
+              'Authorization': 'Bearer test'
+            },
+            signal: AbortSignal.timeout(5000)
+          });
+          return {
+            status: 'ok',
+            version: 'Connected'
+          };
+        } catch (error) {
+          if (error.name === 'AbortError') {
+            return {
+              status: 'failed',
+              error: 'Connection timeout'
+            };
+          }
+          return {
+            status: 'ok',
+            version: 'Connected (API responded)'
+          };
+        }
+      }
+    });
+  }
   const results = [];
   for (const check of checks) {
     try {
-      const {
-        stdout: version
-      } = await execAsync(check.command, {
-        encoding: 'utf8'
-      });
+      let result;
+      if (check.async && check.checkFunction) {
+        result = await check.checkFunction();
+      } else if (check.command) {
+        const {
+          stdout: version
+        } = await execAsync(check.command, {
+          encoding: 'utf8',
+          timeout: 10000
+        });
+        result = {
+          status: 'ok',
+          version: version.trim()
+        };
+
+        // Version checking for critical components
+        if (check.minVersion && check.name === 'Node.js') {
+          const versionNum = version.trim().replace('v', '');
+          if (versionNum < check.minVersion) {
+            result = {
+              status: 'warning',
+              version: version.trim(),
+              warning: `Node.js ${check.minVersion}+ recommended, found ${versionNum}`
+            };
+          }
+        }
+      } else {
+        result = {
+          status: 'skipped',
+          version: 'N/A'
+        };
+      }
       results.push({
-        name: check.name,
-        status: 'ok',
-        version: version.trim()
+        ...check,
+        ...result
       });
     } catch (error) {
       results.push({
-        name: check.name,
+        ...check,
         status: 'failed',
         error: error.message
       });

package/dist/lib/shared/deployment/credential-collector.js

@@ -11,7 +11,8 @@
 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 '../../../src/utils/cloudflare/api.js';
+import { CloudflareAPI } from '@tamyla/clodo-framework/utils/cloudflare';
+import { validatePrerequisites } from '../cloudflare/ops.js';
 export class DeploymentCredentialCollector {
   constructor(options = {}) {
     this.servicePath = options.servicePath || '.';
@@ -29,6 +30,10 @@ export class DeploymentCredentialCollector {
    * 4. Return complete credential set
    */
   async collectCredentials(options = {}) {
+    // First, check prerequisites
+    if (!this.quiet) {
+      await this.displayPrerequisites(options);
+    }
     const startCredentials = {
       token: options.token || process.env.CLOUDFLARE_API_TOKEN || null,
       accountId: options.accountId || process.env.CLOUDFLARE_ACCOUNT_ID || null,
@@ -36,6 +41,11 @@ export class DeploymentCredentialCollector {
       zoneName: null // Will be populated when fetching zone
     };
 
+    // Show credential status if not quiet
+    if (!this.quiet) {
+      this.displayCredentialStatus(startCredentials, options);
+    }
+
     // All credentials provided - quick path
     if (startCredentials.token && startCredentials.accountId && startCredentials.zoneId) {
       if (!this.quiet) {
@@ -247,5 +257,128 @@ export class DeploymentCredentialCollector {
   cleanup() {
     closePrompts();
   }
+
+  /**
+   * Display prerequisite check results
+   * @param {Object} options - Options for prerequisite checking
+   */
+  async displayPrerequisites(options = {}) {
+    console.log(chalk.cyan('\n🔧 Deployment Prerequisites\n'));
+    try {
+      const results = await validatePrerequisites({
+        checkAuth: options.checkAuth || false,
+        checkNetwork: options.checkNetwork || false,
+        verbose: !this.quiet
+      });
+      let allOk = true;
+      let hasWarnings = false;
+      results.forEach(result => {
+        const icon = result.status === 'ok' ? '✅' : result.status === 'warning' ? '⚠️' : result.status === 'failed' ? '❌' : '⏭️';
+        const color = result.status === 'ok' ? chalk.green : result.status === 'warning' ? chalk.yellow : result.status === 'failed' ? chalk.red : chalk.gray;
+        console.log(`${icon} ${color(result.name)}: ${result.version || 'N/A'}`);
+        if (result.description) {
+          console.log(`   ${chalk.gray(result.description)}`);
+        }
+        if (result.warning) {
+          console.log(`   ${chalk.yellow('⚠️  ' + result.warning)}`);
+          hasWarnings = true;
+        }
+        if (result.error) {
+          console.log(`   ${chalk.red('❌ ' + result.error)}`);
+          allOk = false;
+        }
+        if (result.status === 'failed' && result.required) {
+          console.log(`   ${chalk.red('💡 Required for deployment - please install/update ' + result.name.toLowerCase())}`);
+        }
+      });
+      console.log('');
+
+      // Summary
+      if (allOk && !hasWarnings) {
+        console.log(chalk.green('🎉 All prerequisites met - ready for deployment!\n'));
+      } else if (allOk && hasWarnings) {
+        console.log(chalk.yellow('⚠️  Prerequisites OK but with warnings - deployment may proceed\n'));
+      } else {
+        console.log(chalk.red('❌ Some required prerequisites are missing - please resolve before deploying\n'));
+      }
+    } catch (error) {
+      console.log(chalk.yellow(`⚠️  Could not check prerequisites: ${error.message}\n`));
+    }
+  }
+
+  /**
+   * Display credential status showing what's available vs missing
+   * @param {Object} credentials - Current credential state
+   * @param {Object} options - CLI options
+   */
+  displayCredentialStatus(credentials, options) {
+    console.log(chalk.cyan('\n🔍 Credential Status\n'));
+    const status = {
+      token: {
+        available: !!credentials.token,
+        source: this.getCredentialSource('token', credentials.token, options.token),
+        required: true
+      },
+      accountId: {
+        available: !!credentials.accountId,
+        source: this.getCredentialSource('accountId', credentials.accountId, options.accountId),
+        required: false
+      },
+      zoneId: {
+        available: !!credentials.zoneId,
+        source: this.getCredentialSource('zoneId', credentials.zoneId, options.zoneId),
+        required: false
+      }
+    };
+
+    // Display each credential
+    Object.entries(status).forEach(([key, info]) => {
+      const icon = info.available ? '✅' : '❌';
+      const color = info.available ? chalk.green : chalk.red;
+      const label = key === 'token' ? 'API Token' : key === 'accountId' ? 'Account ID' : 'Zone ID';
+      const envVar = key === 'token' ? 'CLOUDFLARE_API_TOKEN' : key === 'accountId' ? 'CLOUDFLARE_ACCOUNT_ID' : 'CLOUDFLARE_ZONE_ID';
+      console.log(`${icon} ${color(label)}: ${info.available ? info.source : 'Missing'}`);
+      if (!info.available) {
+        console.log(`   ${chalk.gray(`Set via --${key.replace('Id', '-id')} flag or ${envVar} environment variable`)}`);
+        console.log(`   ${chalk.gray('To set environment variable:')}`);
+        console.log(`   ${chalk.gray(`  Windows PowerShell: $env:${envVar}="your-value-here"`)}`);
+        console.log(`   ${chalk.gray(`  Windows CMD: set ${envVar}=your-value-here`)}`);
+        console.log(`   ${chalk.gray(`  Linux/macOS: export ${envVar}="your-value-here"`)}`);
+        console.log(`   ${chalk.gray(`  Or add to .env file: ${envVar}=your-value-here`)}`);
+        console.log('');
+      }
+    });
+    console.log('');
+
+    // Summary
+    const availableCount = Object.values(status).filter(s => s.available).length;
+    const totalCount = Object.keys(status).length;
+    if (availableCount === totalCount) {
+      console.log(chalk.green('🎉 All credentials available - ready for deployment!\n'));
+    } else if (availableCount >= 1) {
+      console.log(chalk.yellow(`⚠️  ${availableCount}/${totalCount} credentials available. Missing credentials will be fetched interactively.\n`));
+    } else {
+      console.log(chalk.red('❌ No credentials found. Interactive collection required.\n'));
+    }
+  }
+
+  /**
+   * Get the source of a credential (flag, env var, or none)
+   * @param {string} key - Credential key
+   * @param {*} value - Credential value
+   * @param {*} flagValue - CLI flag value
+   * @returns {string} Source description
+   */
+  getCredentialSource(key, value, flagValue) {
+    if (!value) return 'Not set';
+
+    // Check if it came from CLI flag
+    if (flagValue) return 'CLI flag';
+
+    // Check if it came from environment variable
+    const envVar = key === 'token' ? 'CLOUDFLARE_API_TOKEN' : key === 'accountId' ? 'CLOUDFLARE_ACCOUNT_ID' : 'CLOUDFLARE_ZONE_ID';
+    if (process.env[envVar]) return 'Environment variable';
+    return 'Unknown source';
+  }
 }
 export default DeploymentCredentialCollector;

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

@@ -4,7 +4,11 @@
  */
 
 export { DeploymentValidator } from './validator.js';
-export { MultiDomainOrchestrator } from '../../../src/orchestration/multi-domain-orchestrator.js';
-export { CrossDomainCoordinator } from '../../../src/orchestration/cross-domain-coordinator.js';
+export { MultiDomainOrchestrator } from '@tamyla/clodo-framework/orchestration';
+export { CrossDomainCoordinator } from '@tamyla/clodo-framework/orchestration';
 export { DeploymentAuditor } from './auditor.js';
-export { RollbackManager } from './rollback-manager.js';
+export { RollbackManager } from './rollback-manager.js';
+export { DeploymentCredentialCollector } from './credential-collector.js';
+
+// Export workflow modules
+export * from './workflows/index.js';

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

@@ -6,4 +6,4 @@
  * In npm packages, this resolves to dist/deployment/rollback-manager.js
  */
 
-export { RollbackManager } from '../../../src/deployment/rollback-manager.js';
+export { RollbackManager } from '@tamyla/clodo-framework/deployment';

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

@@ -42,7 +42,7 @@ export class D1ErrorRecoveryManager {
         // Import WranglerDeployer for D1 error handling
         const {
           WranglerDeployer
-        } = await import('../../../src/deployment/wrangler-deployer.js');
+        } = await import('@tamyla/clodo-framework/deployment');
         deployer = new WranglerDeployer({
           cwd: config.cwd || process.cwd(),
           environment: config.environment

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

@@ -0,0 +1,13 @@
+/**
+ * Deployment Workflows Module
+ * Exports all interactive deployment workflow coordinators and helpers
+ */
+
+export { InteractiveDeploymentCoordinator } from './interactive-deployment-coordinator.js';
+export { InteractiveConfirmationWorkflow } from './interactive-confirmation.js';
+export { InteractiveDatabaseWorkflow } from './interactive-database-workflow.js';
+export { InteractiveDomainInfoGatherer } from './interactive-domain-info-gatherer.js';
+export { InteractiveSecretWorkflow } from './interactive-secret-workflow.js';
+export { InteractiveTestingWorkflow } from './interactive-testing-workflow.js';
+export { InteractiveValidationWorkflow } from './interactive-validation.js';
+export { DeploymentSummaryWorkflow } from './deployment-summary.js';

package/dist/lib/shared/deployment/workflows/interactive-confirmation.js

@@ -7,7 +7,7 @@
  * @module interactive-confirmation
  */
 
-import { askYesNo } from '../utils/interactive-prompts.js';
+import { askYesNo } from '../../utils/interactive-prompts.js';
 
 /**
  * Interactive Confirmation Manager

package/dist/lib/shared/deployment/workflows/interactive-deployment-coordinator.js

@@ -0,0 +1,229 @@
+/**
+ * Interactive Deployment Coordinator
+ *
+ * Restores the interactive deployment functionality that was lost during enterprise code separation.
+ * Orchestrates the interactive workflows that were extracted from enterprise-deployment/master-deploy.js.
+ *
+ * This coordinator brings together:
+ * - InteractiveDomainInfoGatherer
+ * - InteractiveDatabaseWorkflow
+ * - InteractiveSecretWorkflow
+ * - InteractiveValidation
+ * - InteractiveConfirmation
+ * - InteractiveTestingWorkflow
+ *
+ * @module interactive-deployment-coordinator
+ */
+
+import { InteractiveDomainInfoGatherer } from './interactive-domain-info-gatherer.js';
+import { InteractiveDatabaseWorkflow } from './interactive-database-workflow.js';
+import { InteractiveSecretWorkflow } from './interactive-secret-workflow.js';
+import { InteractiveValidation } from './interactive-validation.js';
+import { InteractiveConfirmation } from './interactive-confirmation.js';
+import { InteractiveTestingWorkflow } from './interactive-testing-workflow.js';
+import { Clodo } from '@tamyla/clodo-framework';
+import { OutputFormatter } from '../../utils/output-formatter.js';
+import { DeploymentCredentialCollector } from '../credential-collector.js';
+
+/**
+ * Interactive Deployment Coordinator
+ * Orchestrates the complete interactive deployment workflow
+ */
+export class InteractiveDeploymentCoordinator {
+  /**
+   * @param {Object} options - Coordinator options
+   * @param {string} options.servicePath - Path to service directory
+   * @param {string} options.environment - Target environment
+   * @param {string} options.domain - Specific domain (optional)
+   * @param {boolean} options.dryRun - Dry run mode
+   * @param {Object} options.credentials - Cloudflare credentials
+   * @param {boolean} options.checkPrereqs - Check prerequisites
+   * @param {boolean} options.checkAuth - Check authentication
+   * @param {boolean} options.checkNetwork - Check network connectivity
+   * @param {boolean} options.verbose - Verbose output
+   * @param {boolean} options.quiet - Quiet output
+   * @param {boolean} options.json - JSON output
+   */
+  constructor(options = {}) {
+    this.options = options;
+    this.output = new OutputFormatter(options);
+    this.deploymentState = {
+      config: {},
+      validation: {},
+      resources: {},
+      testing: {}
+    };
+
+    // Initialize credential collector
+    this.credentialCollector = new DeploymentCredentialCollector({
+      quiet: options.quiet,
+      servicePath: options.servicePath
+    });
+
+    // Initialize interactive workflow components
+    this.workflows = {
+      domainGatherer: new InteractiveDomainInfoGatherer({
+        interactive: true,
+        configCache: null // TODO: Add config cache if available
+      }),
+      databaseWorkflow: new InteractiveDatabaseWorkflow({
+        interactive: true
+      }),
+      secretWorkflow: new InteractiveSecretWorkflow({
+        interactive: true
+      }),
+      validation: new InteractiveValidation({
+        interactive: true
+      }),
+      confirmation: InteractiveConfirmation,
+      testingWorkflow: new InteractiveTestingWorkflow({
+        interactive: true
+      })
+    };
+  }
+
+  /**
+   * Run the complete interactive deployment workflow
+   * @returns {Promise<Object>} Deployment result
+   */
+  async runInteractiveDeployment() {
+    try {
+      console.log('\n🔄 Starting Interactive Deployment Workflow...\n');
+
+      // Phase 1: Gather domain and environment information
+      await this.gatherDeploymentInfo();
+
+      // Phase 2: Configure database resources
+      await this.configureDatabase();
+
+      // Phase 3: Configure secrets and credentials
+      await this.configureSecrets();
+
+      // Phase 4: Validate configuration
+      await this.validateConfiguration();
+
+      // Phase 5: Show final confirmation
+      await this.showConfirmation();
+
+      // Phase 6: Execute deployment
+      const result = await this.executeDeployment();
+
+      // Phase 7: Run post-deployment testing
+      await this.runPostDeploymentTests();
+      return result;
+    } catch (error) {
+      this.output.error(`Interactive deployment failed: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Phase 1: Gather domain and environment information
+   */
+  async gatherDeploymentInfo() {
+    console.log('📋 Phase 1: Gathering Deployment Information');
+    console.log('─'.repeat(50));
+
+    // Start with basic config from options
+    this.deploymentState.config = {
+      servicePath: this.options.servicePath || '.',
+      environment: this.options.environment || 'production',
+      domain: this.options.domain,
+      dryRun: this.options.dryRun || false
+    };
+
+    // Collect credentials with prerequisite checking
+    const credentialOptions = {
+      token: this.options.credentials?.token,
+      accountId: this.options.credentials?.accountId,
+      zoneId: this.options.credentials?.zoneId,
+      checkAuth: this.options.checkAuth,
+      checkNetwork: this.options.checkNetwork
+    };
+    this.deploymentState.config.credentials = await this.credentialCollector.collectCredentials(credentialOptions);
+
+    // Use interactive domain gatherer for missing information
+    if (!this.deploymentState.config.domain) {
+      this.deploymentState.config = await this.workflows.domainGatherer.gatherSingleDomainInfo(this.deploymentState.config);
+    }
+    console.log('✅ Domain information gathered\n');
+  }
+
+  /**
+   * Phase 2: Configure database resources
+   */
+  async configureDatabase() {
+    console.log('🗄️  Phase 2: Configuring Database Resources');
+    console.log('─'.repeat(50));
+    this.deploymentState.resources.database = await this.workflows.databaseWorkflow.handleDatabaseSetup(this.deploymentState.config.domain, this.deploymentState.config.environment, {
+      interactive: true
+    });
+    console.log('✅ Database configuration complete\n');
+  }
+
+  /**
+   * Phase 3: Configure secrets and credentials
+   */
+  async configureSecrets() {
+    console.log('🔐 Phase 3: Configuring Secrets & Credentials');
+    console.log('─'.repeat(50));
+    const workerName = `${this.deploymentState.config.domain}-data-service`;
+    this.deploymentState.resources.secrets = await this.workflows.secretWorkflow.handleSecretManagement(this.deploymentState.config.domain, this.deploymentState.config.environment, workerName, {
+      interactive: true
+    });
+    console.log('✅ Secrets configuration complete\n');
+  }
+
+  /**
+   * Phase 4: Validate configuration
+   */
+  async validateConfiguration() {
+    console.log('✅ Phase 4: Validating Configuration');
+    console.log('─'.repeat(50));
+    this.deploymentState.validation = await this.workflows.validation.executePreDeploymentChecks(this.deploymentState.config);
+    console.log('✅ Configuration validation complete\n');
+  }
+
+  /**
+   * Phase 5: Show final confirmation
+   */
+  async showConfirmation() {
+    console.log('🎯 Phase 5: Final Confirmation');
+    console.log('─'.repeat(50));
+    await this.workflows.confirmation.showFinalConfirmation(this.deploymentState.config, this.deploymentState, {
+      defaultAnswer: 'n'
+    });
+    console.log('✅ Deployment confirmed\n');
+  }
+
+  /**
+   * Phase 6: Execute deployment
+   */
+  async executeDeployment() {
+    console.log('🚀 Phase 6: Executing Deployment');
+    console.log('─'.repeat(50));
+    const result = await Clodo.deploy({
+      servicePath: this.deploymentState.config.servicePath,
+      environment: this.deploymentState.config.environment,
+      domain: this.deploymentState.config.domain,
+      dryRun: this.deploymentState.config.dryRun,
+      credentials: this.deploymentState.config.credentials
+    });
+    if (result.success) {
+      console.log('✅ Deployment executed successfully\n');
+    } else {
+      throw new Error('Deployment execution failed');
+    }
+    return result;
+  }
+
+  /**
+   * Phase 7: Run post-deployment testing
+   */
+  async runPostDeploymentTests() {
+    console.log('🧪 Phase 7: Running Post-Deployment Tests');
+    console.log('─'.repeat(50));
+    this.deploymentState.testing = await this.workflows.testingWorkflow.executePostDeploymentTesting(this.deploymentState.config);
+    console.log('✅ Post-deployment testing complete\n');
+  }
+}

package/dist/lib/shared/deployment/workflows/interactive-domain-info-gatherer.js

@@ -7,7 +7,7 @@
  * @module interactive-domain-info-gatherer
  */
 
-import { askUser, askYesNo, askChoice } from '../utils/interactive-prompts.js';
+import { askUser, askYesNo, askChoice } from '../../utils/interactive-prompts.js';
 
 /**
  * Interactive Domain Info Gatherer

package/dist/lib/shared/deployment/workflows/interactive-secret-workflow.js

@@ -7,9 +7,9 @@
  * @module interactive-secret-workflow
  */
 
-import { askYesNo } from '../utils/interactive-prompts.js';
-import { generateSecrets, saveSecrets, distributeSecrets } from '../security/secret-generator.js';
-import { deploySecret } from '../cloudflare/ops.js';
+import { askYesNo } from '../../utils/interactive-prompts.js';
+import { generateSecrets, saveSecrets, distributeSecrets } from '../../security/secret-generator.js';
+import { deploySecret } from '../../cloudflare/ops.js';
 import { join } from 'path';
 import { existsSync, readFileSync } from 'fs';
 

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

@@ -7,8 +7,8 @@
  * @module interactive-testing-workflow
  */
 
-import { askYesNo } from '../utils/interactive-prompts.js';
-import { checkHealth } from '../monitoring/health-checker.js';
+import { askYesNo } from '../../utils/interactive-prompts.js';
+import { checkHealth } from '../../monitoring/health-checker.js';
 
 /**
  * Interactive Testing Workflow

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

@@ -7,8 +7,8 @@
  * @module interactive-validation
  */
 
-import { askYesNo } from '../utils/interactive-prompts.js';
-import { validatePrerequisites, checkAuth, authenticate, workerExists } from '../cloudflare/ops.js';
+import { askYesNo } from '../../utils/interactive-prompts.js';
+import { validatePrerequisites, checkAuth, authenticate, workerExists } from '../../cloudflare/ops.js';
 
 /**
  * Interactive Validation Workflow

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

@@ -12,10 +12,16 @@ import http from 'http';
 const execAsync = promisify(exec);
 
 // Load framework configuration
-const {
-  frameworkConfig
-} = await import('../../../src/utils/framework-config.js');
-const timing = frameworkConfig.getTiming();
+// const { frameworkConfig } = await import('@tamyla/clodo-framework/utils');
+// const timing = frameworkConfig.getTiming();
+
+// Use default timing values for now
+const timing = {
+  healthCheckTimeout: 10000,
+  deploymentTimeout: 300000,
+  deploymentInterval: 5000,
+  endpointValidationTimeout: 5000
+};
 function makeHttpRequest(url, method = 'GET', timeout = 5000) {
   return new Promise((resolve, reject) => {
     const protocol = url.startsWith('https:') ? https : http;
@@ -546,7 +552,7 @@ export async function verifyWorkerDeployment(workerName, credentials, options =
       }
       const {
         CloudflareAPI
-      } = await import('../../../src/utils/cloudflare/api.js');
+      } = await import('@tamyla/clodo-framework/utils/cloudflare');
       const cfApi = new CloudflareAPI(credentials.token);
 
       // List all workers to find ours

package/dist/lib/shared/validation/ValidationRegistry.js

@@ -8,7 +8,7 @@
 /**
  * Import validators from utils (source of truth)
  */
-import { validateServiceName, validateDomainName, validateCloudflareToken, validateCloudflareId, validateServiceType, validateEnvironment } from '../../../src/utils/validation.js';
+import { validateServiceName, validateDomainName, validateCloudflareToken, validateCloudflareId, validateServiceType, validateEnvironment } from '@tamyla/clodo-framework/utils';
 
 /**
  * Validation Registry - Single source of truth for all validators

package/dist/utils/deployment/index.js

@@ -4,4 +4,5 @@
 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 { askUser, askYesNo, askChoice, closePrompts } from '../interactive-prompts.js';
+export { DeploymentCredentialCollector } from '../../../lib/shared/deployment/credential-collector.js';

package/dist/utils/health-checker.js

@@ -1,43 +1,41 @@
 /**
  * Health Checker Module
  * Endpoint health checking and validation utilities
+ * Worker-compatible version using fetch API
  */
 
-import https from 'https';
-import http from 'http';
-
 /**
- * Make HTTP request with timeout
+ * Make HTTP request with timeout using fetch
  * @param {string} url - URL to request
  * @param {string} method - HTTP method
  * @param {number} timeout - Request timeout in ms
  * @returns {Promise<Object>} Response data and status
  */
-function makeHttpRequest(url, method = 'GET', timeout = 5000) {
-  return new Promise((resolve, reject) => {
-    const protocol = url.startsWith('https:') ? https : http;
-    const req = protocol.request(url, {
+async function makeHttpRequest(url, method = 'GET', timeout = 5000) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetch(url, {
       method,
-      timeout
-    }, res => {
-      let data = '';
-      res.on('data', chunk => data += chunk);
-      res.on('end', () => {
-        resolve({
-          data,
-          statusCode: res.statusCode
-        });
-      });
-    });
-    req.on('error', err => {
-      reject(err);
+      signal: controller.signal,
+      headers: {
+        'User-Agent': 'Clodo-Framework-Health-Check/1.0'
+      }
     });
-    req.on('timeout', () => {
-      req.destroy();
-      reject(new Error('Request timed out'));
-    });
-    req.end();
-  });
+    clearTimeout(timeoutId);
+    const data = await response.text();
+    return {
+      data,
+      statusCode: response.status,
+      headers: Object.fromEntries(response.headers.entries())
+    };
+  } catch (error) {
+    clearTimeout(timeoutId);
+    if (error.name === 'AbortError') {
+      throw new Error('Request timed out');
+    }
+    throw error;
+  }
 }
 
 /**
@@ -47,55 +45,34 @@ function makeHttpRequest(url, method = 'GET', timeout = 5000) {
  * @returns {Promise<Object>} Health check result
  */
 export async function checkHealth(url, timeout = 10000) {
-  return new Promise((resolve, reject) => {
-    const protocol = url.startsWith('https:') ? https : http;
-    const healthUrl = `${url.replace(/\/$/, '')}/health`;
-    const req = protocol.get(healthUrl, {
-      timeout
-    }, res => {
-      let data = '';
-      res.on('data', chunk => data += chunk);
-      res.on('end', () => {
-        try {
-          const result = {
-            url: healthUrl,
-            status: res.statusCode,
-            healthy: res.statusCode >= 200 && res.statusCode < 300,
-            responseTime: Date.now() - req.startTime,
-            data: data ? JSON.parse(data) : null
-          };
-          resolve(result);
-        } catch (parseError) {
-          resolve({
-            url: healthUrl,
-            status: res.statusCode,
-            healthy: res.statusCode >= 200 && res.statusCode < 300,
-            responseTime: Date.now() - req.startTime,
-            data: null,
-            parseError: parseError.message
-          });
-        }
-      });
-    });
-    req.startTime = Date.now();
-    req.on('error', err => {
-      reject({
-        url: healthUrl,
-        error: err.message,
-        healthy: false,
-        responseTime: Date.now() - req.startTime
-      });
-    });
-    req.on('timeout', () => {
-      req.destroy();
-      reject({
-        url: healthUrl,
-        error: 'Health check timed out',
-        healthy: false,
-        responseTime: timeout
-      });
-    });
-  });
+  const startTime = Date.now();
+  const healthUrl = `${url.replace(/\/$/, '')}/health`;
+  try {
+    const result = await makeHttpRequest(healthUrl, 'GET', timeout);
+    const responseTime = Date.now() - startTime;
+    let data = null;
+    let parseError = null;
+    try {
+      data = result.data ? JSON.parse(result.data) : null;
+    } catch (error) {
+      parseError = error.message;
+    }
+    return {
+      url: healthUrl,
+      status: result.statusCode,
+      healthy: result.statusCode >= 200 && result.statusCode < 300,
+      responseTime,
+      data,
+      parseError
+    };
+  } catch (error) {
+    return {
+      url: healthUrl,
+      error: error.message,
+      healthy: false,
+      responseTime: Date.now() - startTime
+    };
+  }
 }
 
 /**

package/dist/utils/index.js

@@ -32,5 +32,8 @@ export const createLogger = (prefix = 'ClodoFramework') => {
 // Health checking utilities
 export * from './health-checker.js';
 
+// Framework configuration
+export * from './framework-config.js';
+
 // Deployment utilities
 export * from './deployment/index.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tamyla/clodo-framework",
-  "version": "3.2.0",
+  "version": "3.2.1",
   "description": "Reusable framework for Clodo-style software architecture on Cloudflare Workers + D1",
   "type": "module",
   "sideEffects": [
@@ -22,7 +22,7 @@
     "./config/customers": "./dist/config/customers.js",
     "./utils/config": "./dist/utils/config/unified-config-manager.js",
     "./worker": "./dist/worker/index.js",
-    "./utils": "./dist/utils/index.js",
+    "./utils/cloudflare": "./dist/utils/cloudflare/index.js",
     "./utils/deployment": "./dist/utils/deployment/index.js",
     "./orchestration": "./dist/orchestration/index.js",
     "./deployment": "./dist/deployment/index.js",

package/templates/generic/src/worker/index.js

@@ -1,4 +1,4 @@
-import { initializeService, createFeatureGuard, COMMON_FEATURES } from '@tamyla/clodo-framework';
+import { initializeService, createFeatureGuard, COMMON_FEATURES } from '@tamyla/clodo-framework/worker';
 import { domains } from './config/domains.js';
 
 /**

package/templates/static-site/src/worker/index.js

@@ -1,4 +1,4 @@
-import { initializeService, createFeatureGuard, COMMON_FEATURES } from '@tamyla/clodo-framework';
+import { initializeService, createFeatureGuard, COMMON_FEATURES } from '@tamyla/clodo-framework/worker';
 import { domains } from './config/domains.js';
 
 /**