@tamyla/clodo-framework 3.1.12 → 3.1.14

package/CHANGELOG.md

@@ -1,3 +1,18 @@
+## [3.1.14](https://github.com/tamylaa/clodo-framework/compare/v3.1.13...v3.1.14) (2025-10-27)
+
+
+### Bug Fixes
+
+* restore smart credential collection flow in deploy command ([a3e94f6](https://github.com/tamylaa/clodo-framework/commit/a3e94f6efe4a41c380badfc7a104e32bfba9fe9a))
+
+## [3.1.13](https://github.com/tamylaa/clodo-framework/compare/v3.1.12...v3.1.13) (2025-10-27)
+
+
+### Bug Fixes
+
+* add comprehensive test coverage for service validation ([393e6d2](https://github.com/tamylaa/clodo-framework/commit/393e6d268348cc2926c80f0d3f6cd5377c2875a2))
+* add intelligent Cloudflare service detection and validation ([a680006](https://github.com/tamylaa/clodo-framework/commit/a6800063e2df8f8d6fa7660079cd22eb3f9a4a97))
+
 ## [3.1.12](https://github.com/tamylaa/clodo-framework/compare/v3.1.11...v3.1.12) (2025-10-27)
 
 

package/dist/bin/commands/deploy.js

@@ -2,100 +2,97 @@
  * Deploy Command - Smart minimal input deployment with service detection
  * 
  * Input Strategy: SMART MINIMAL
- * - Detects if project is a service (clodo-service-manifest.json)
- * - Gathers credentials smartly: env vars → flags → fail with helpful message (never prompt)
+ * - Detects Clodo services OR legacy services (wrangler.toml)
+ * - Supports multiple manifest locations
+ * - Gathers credentials smartly: env vars → flags → interactive collection with auto-fetch
+ * - Validates token and fetches account ID & zone ID from Cloudflare
  * - Integrates with modular-enterprise-deploy.js for clean CLI-based deployment
  */
 
 import chalk from 'chalk';
-import { existsSync, readFileSync } from 'fs';
-import { resolve, join } from 'path';
+import { resolve } from 'path';
+import { ManifestLoader } from '../shared/config/manifest-loader.js';
+import { CloudflareServiceValidator } from '../shared/config/cloudflare-service-validator.js';
+import { DeploymentCredentialCollector } from '../shared/deployment/credential-collector.js';
 export function registerDeployCommand(program) {
   program.command('deploy').description('Deploy a Clodo service with smart credential handling').option('--token <token>', 'Cloudflare API token').option('--account-id <id>', 'Cloudflare account ID').option('--zone-id <id>', 'Cloudflare zone ID').option('--dry-run', 'Simulate deployment without making changes').option('--quiet', 'Quiet mode - minimal output').option('--service-path <path>', 'Path to service directory', '.').action(async options => {
     try {
       console.log(chalk.cyan('\n🚀 Clodo Service Deployment\n'));
 
-      // Step 1: Detect if this is a service project
+      // Step 1: Load and validate service configuration
       const servicePath = resolve(options.servicePath);
-      const manifestPath = join(servicePath, 'clodo-service-manifest.json');
-      if (!existsSync(manifestPath)) {
-        console.error(chalk.red('❌ This is not a Clodo service project'));
-        console.error(chalk.yellow('\nExpected to find: clodo-service-manifest.json'));
-        console.error(chalk.cyan('\nAre you trying to deploy the framework itself?'));
-        console.error(chalk.white('The clodo-framework repository is a library, not deployable.'));
-        console.error(chalk.white('Create a service first: npx clodo-service create'));
+      const serviceConfig = await ManifestLoader.loadAndValidateCloudflareService(servicePath);
+      if (!serviceConfig.manifest) {
+        if (serviceConfig.error === 'NOT_A_CLOUDFLARE_SERVICE') {
+          ManifestLoader.printNotCloudflareServiceError(servicePath);
+        } else if (serviceConfig.error === 'CLOUDFLARE_SERVICE_INVALID') {
+          // Pass false because we're validating a detected service, not a Clodo manifest
+          ManifestLoader.printValidationErrors(serviceConfig.validationResult, false);
+        }
         process.exit(1);
       }
 
-      // Read service manifest
-      let manifest;
-      try {
-        const manifestContent = readFileSync(manifestPath, 'utf8');
-        manifest = JSON.parse(manifestContent);
-      } catch (err) {
-        console.error(chalk.red('❌ Failed to read service manifest'));
-        console.error(chalk.yellow(`Error: ${err.message}`));
-        process.exit(1);
+      // Print service info and validation results
+      if (serviceConfig.validationResult) {
+        CloudflareServiceValidator.printValidationReport(serviceConfig.validationResult.validation);
       }
-      const serviceName = manifest.serviceName || 'unknown-service';
-      const serviceType = manifest.serviceType || 'unknown-type';
-      console.log(chalk.white(`Service: ${chalk.bold(serviceName)}`));
-      console.log(chalk.white(`Type: ${serviceType}`));
-      console.log(chalk.white(`Path: ${servicePath}\n`));
-
-      // Step 2: Smart credential gathering
-      // Priority: flags → environment variables → fail with helpful message
-      const credentials = {
-        token: options.token || process.env.CLOUDFLARE_API_TOKEN,
-        accountId: options.accountId || process.env.CLOUDFLARE_ACCOUNT_ID,
-        zoneId: options.zoneId || process.env.CLOUDFLARE_ZONE_ID
-      };
+      ManifestLoader.printManifestInfo(serviceConfig.manifest);
+      console.log(chalk.gray(`Configuration loaded from: ${serviceConfig.foundAt}\n`));
 
-      // Check for missing credentials
-      const missing = [];
-      if (!credentials.token) missing.push('CLOUDFLARE_API_TOKEN');
-      if (!credentials.accountId) missing.push('CLOUDFLARE_ACCOUNT_ID');
-      if (!credentials.zoneId) missing.push('CLOUDFLARE_ZONE_ID');
-      if (missing.length > 0) {
-        console.error(chalk.red('❌ Missing required Cloudflare credentials\n'));
-        console.error(chalk.white('Please provide via:'));
-        console.error(chalk.cyan('  Environment Variables:'));
-        missing.forEach(key => {
-          console.error(chalk.white(`    export ${key}=<your-${key.toLowerCase()}>`));
+      // Step 2: Smart credential gathering with interactive collection
+      // Uses DeploymentCredentialCollector which:
+      // - Checks flags and env vars first
+      // - Prompts for API token if needed
+      // - Validates token and auto-fetches account ID & zone ID
+      // - Caches credentials for future use
+      const credentialCollector = new DeploymentCredentialCollector({
+        servicePath: servicePath,
+        quiet: options.quiet
+      });
+      let credentials;
+      try {
+        credentials = await credentialCollector.collectCredentials({
+          token: options.token,
+          accountId: options.accountId,
+          zoneId: options.zoneId
         });
-        console.error(chalk.cyan('\n  Command Flags:'));
-        if (missing.includes('CLOUDFLARE_API_TOKEN')) {
-          console.error(chalk.white('    --token <token>'));
-        }
-        if (missing.includes('CLOUDFLARE_ACCOUNT_ID')) {
-          console.error(chalk.white('    --account-id <id>'));
-        }
-        if (missing.includes('CLOUDFLARE_ZONE_ID')) {
-          console.error(chalk.white('    --zone-id <id>'));
-        }
-        console.error(chalk.cyan('\n  Example:'));
-        console.error(chalk.white('    npx clodo-service deploy --token abc123 --account-id xyz789 --zone-id def456'));
-        console.error(chalk.white('    OR'));
-        console.error(chalk.white('    export CLOUDFLARE_API_TOKEN=abc123'));
-        console.error(chalk.white('    export CLOUDFLARE_ACCOUNT_ID=xyz789'));
-        console.error(chalk.white('    export CLOUDFLARE_ZONE_ID=def456'));
-        console.error(chalk.white('    npx clodo-service deploy\n'));
-        process.exit(1);
+      } finally {
+        credentialCollector.cleanup();
       }
 
       // Step 3: Extract configuration from manifest
-      const config = manifest.configuration || {};
-      const domain = config.domain || config.domainName;
-      if (!domain) {
-        console.error(chalk.red('❌ No domain configured in service manifest'));
-        console.error(chalk.yellow('Update clodo-service-manifest.json with domain configuration'));
-        process.exit(1);
+      const manifest = serviceConfig.manifest;
+      const config = manifest.deployment || manifest.configuration || {};
+
+      // Extract service metadata
+      const serviceName = manifest.serviceName || 'unknown-service';
+      const serviceType = manifest.serviceType || 'generic';
+
+      // For detected Cloudflare services, domain comes from wrangler.toml or environment
+      // For Clodo services, use first domain if available
+      let domain = null;
+      const domains = config.domains || [];
+      if (domains.length > 0) {
+        // Clodo service with multiple domains
+        domain = domains[0].name || domains[0];
+      } else if (manifest._source === 'cloudflare-service-detected') {
+        // Detected CF service - get domain from route or config
+        // For now, use a placeholder since we don't have explicit domain routing in detected services
+        domain = 'workers.cloudflare.com';
+        console.log(chalk.gray('Note: Using Cloudflare Workers default domain (add routes in wrangler.toml for custom domains)'));
+      }
+      if (!domain && !options.quiet) {
+        console.error(chalk.yellow('⚠️  No domain configured for deployment'));
+        console.error(chalk.gray('For Clodo services: add deployment.domains in clodo-service-manifest.json'));
+        console.error(chalk.gray('For detected CF services: define routes in wrangler.toml'));
       }
       console.log(chalk.cyan('📋 Deployment Plan:'));
       console.log(chalk.gray('─'.repeat(50)));
       console.log(chalk.white(`Service:  ${serviceName}`));
       console.log(chalk.white(`Type:     ${serviceType}`));
-      console.log(chalk.white(`Domain:   ${domain}`));
+      if (domain) {
+        console.log(chalk.white(`Domain:   ${domain}`));
+      }
       console.log(chalk.white(`Account:  ${credentials.accountId.substring(0, 8)}...`));
       console.log(chalk.white(`Zone:     ${credentials.zoneId.substring(0, 8)}...`));
       console.log(chalk.gray('─'.repeat(50)));

package/dist/bin/shared/config/cloudflare-service-validator.js

@@ -0,0 +1,180 @@
+/**
+ * Cloudflare Service Validator
+ * 
+ * Validates that a directory is a properly formed Cloudflare Workers service
+ * and detects quality issues before deployment attempts
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import chalk from 'chalk';
+import TOML from '@iarna/toml';
+export class CloudflareServiceValidator {
+  /**
+   * Check if directory has basic Cloudflare service signatures
+   * Returns: { isCloudflareService, wranglerPath, packagePath, errors }
+   */
+  static detectCloudflareService(servicePath) {
+    const wranglerPath = join(servicePath, 'wrangler.toml');
+    const packagePath = join(servicePath, 'package.json');
+    const hasWrangler = existsSync(wranglerPath);
+    const hasPackage = existsSync(packagePath);
+    const errors = [];
+    if (!hasWrangler) errors.push('Missing wrangler.toml');
+    if (!hasPackage) errors.push('Missing package.json');
+    return {
+      isCloudflareService: hasWrangler && hasPackage,
+      wranglerPath: hasWrangler ? wranglerPath : null,
+      packagePath: hasPackage ? packagePath : null,
+      errors
+    };
+  }
+
+  /**
+   * Validate service has proper entry points and structure
+   * Returns: { isValid, issues, warnings }
+   */
+  static validateServiceStructure(servicePath, wranglerPath, packagePath) {
+    const issues = [];
+    const warnings = [];
+    try {
+      // Parse files
+      const wranglerContent = readFileSync(wranglerPath, 'utf8');
+      const wranglerConfig = TOML.parse(wranglerContent);
+      const packageContent = readFileSync(packagePath, 'utf8');
+      const packageJson = JSON.parse(packageContent);
+
+      // Check wrangler.toml quality
+      if (!wranglerConfig.name) {
+        issues.push('wrangler.toml: Missing "name" field');
+      }
+      if (!wranglerConfig.main) {
+        warnings.push('wrangler.toml: No "main" entry point specified (will use default)');
+      }
+
+      // Check package.json quality
+      if (!packageJson.name) {
+        issues.push('package.json: Missing "name" field');
+      }
+      if (!packageJson.dependencies && !packageJson.devDependencies) {
+        warnings.push('package.json: No dependencies defined');
+      }
+
+      // Check for common entry points
+      const possibleEntryPoints = ['src/worker/index.js', 'src/index.js', 'index.js', 'dist/index.js', wranglerConfig.main].filter(Boolean);
+      const hasEntryPoint = possibleEntryPoints.some(ep => existsSync(join(servicePath, ep)));
+      if (!hasEntryPoint) {
+        warnings.push(`No recognizable entry point found. Checked: ${possibleEntryPoints.join(', ')}`);
+      }
+
+      // Check for Cloudflare environment
+      const env = wranglerConfig.env || {};
+      if (Object.keys(env).length === 0) {
+        warnings.push('wrangler.toml: No environments configured (production, staging, etc)');
+      }
+
+      // Note: Routes are optional - many services define them in code or use catch-all patterns
+      // Not warning about missing routes here as it's a valid configuration choice
+
+      return {
+        isValid: issues.length === 0,
+        issues,
+        warnings,
+        wranglerConfig,
+        packageJson
+      };
+    } catch (err) {
+      return {
+        isValid: false,
+        issues: [`Failed to parse config files: ${err.message}`],
+        warnings: [],
+        error: err
+      };
+    }
+  }
+
+  /**
+   * Check if service has existing deployment history
+   */
+  static detectExistingDeployments(servicePath) {
+    const possibleLocations = [join(servicePath, '.wrangler'), join(servicePath, 'dist'), join(servicePath, 'build'), join(servicePath, '.deployments')];
+    const existingDeployments = possibleLocations.filter(loc => existsSync(loc));
+    return {
+      hasDeploymentHistory: existingDeployments.length > 0,
+      deploymentMarkers: existingDeployments
+    };
+  }
+
+  /**
+   * Print validation report
+   */
+  static printValidationReport(validation) {
+    if (validation.issues.length > 0) {
+      console.error(chalk.red('\n❌ Service Configuration Issues:\n'));
+      validation.issues.forEach(issue => {
+        console.error(chalk.red(`  • ${issue}`));
+      });
+    }
+    if (validation.warnings.length > 0) {
+      console.warn(chalk.yellow('\n⚠️  Service Configuration Warnings:\n'));
+      validation.warnings.forEach(warning => {
+        console.warn(chalk.yellow(`  • ${warning}`));
+      });
+    }
+    if (validation.isValid && validation.warnings.length === 0) {
+      console.log(chalk.green('\n✅ Service structure looks good!\n'));
+    }
+  }
+
+  /**
+   * Interactive validation: ask user if they want to continue despite warnings
+   */
+  static async askContinueDespiteWarnings() {
+    // This would be called from interactive context
+    // For now, return a promise that can be used in async/await
+    return new Promise(resolve => {
+      // In actual implementation, would use readline or similar
+      // For this stub, we'll indicate the method exists
+      resolve(true);
+    });
+  }
+
+  /**
+   * Comprehensive service validation workflow
+   */
+  static validateForDeployment(servicePath) {
+    // Step 1: Check for basic signatures
+    const detection = this.detectCloudflareService(servicePath);
+    if (!detection.isCloudflareService) {
+      return {
+        canDeploy: false,
+        reason: 'NOT_A_CLOUDFLARE_SERVICE',
+        detection,
+        details: 'This directory does not have the required files for a Cloudflare Workers service.'
+      };
+    }
+
+    // Step 2: Validate structure
+    const validation = this.validateServiceStructure(servicePath, detection.wranglerPath, detection.packagePath);
+    if (!validation.isValid) {
+      return {
+        canDeploy: false,
+        reason: 'SERVICE_CONFIGURATION_INVALID',
+        validation,
+        details: 'The service configuration is invalid and may not deploy correctly.'
+      };
+    }
+
+    // Step 3: Check deployment history
+    const deploymentHistory = this.detectExistingDeployments(servicePath);
+    return {
+      canDeploy: true,
+      reason: validation.warnings.length > 0 ? 'SERVICE_VALID_WITH_WARNINGS' : 'SERVICE_VALID',
+      detection,
+      validation,
+      deploymentHistory,
+      details: 'Service is ready for deployment.'
+    };
+  }
+}
+export default CloudflareServiceValidator;

package/dist/bin/shared/config/manifest-loader.js

@@ -0,0 +1,294 @@
+/**
+ * Manifest Loader - Flexible service manifest detection and loading
+ * 
+ * Supports:
+ * - Clodo Framework generated manifests (service-manifest.json)
+ * - Legacy services (wrangler.toml + package.json)
+ * - Custom manifest locations
+ * - Environment variable overrides
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { join, resolve } from 'path';
+import chalk from 'chalk';
+import { CloudflareServiceValidator } from './cloudflare-service-validator.js';
+
+/**
+ * Possible manifest locations (in order of priority)
+ */
+const MANIFEST_LOCATIONS = ['clodo-service-manifest.json',
+// Standard location (root)
+'.clodo/service-manifest.json',
+// Hidden config directory
+'config/service-manifest.json' // Config subdirectory
+];
+
+/**
+ * Fallback configuration builders for legacy services
+ */
+class LegacyServiceDetector {
+  /**
+   * Build manifest-like config from wrangler.toml + package.json
+   */
+  static async buildFromWrangler(servicePath) {
+    const wranglerPath = join(servicePath, 'wrangler.toml');
+    const packagePath = join(servicePath, 'package.json');
+    if (!existsSync(wranglerPath) || !existsSync(packagePath)) {
+      return null;
+    }
+    try {
+      const packageJson = JSON.parse(readFileSync(packagePath, 'utf8'));
+      return {
+        _source: 'legacy-wrangler',
+        _legacyNote: 'This is a legacy service without a service-manifest.json. Consider running: npx clodo-service init',
+        serviceName: packageJson.name || 'unknown-service',
+        serviceType: 'legacy-workers-project',
+        version: packageJson.version || '1.0.0',
+        isClodoService: false,
+        isLegacyService: true,
+        deployment: {
+          framework: 'wrangler',
+          ready: true,
+          configFiles: {
+            wrangler: './wrangler.toml',
+            package: './package.json'
+          }
+        },
+        metadata: {
+          detectedAt: new Date().toISOString(),
+          framework: 'legacy-wrangler'
+        }
+      };
+    } catch (err) {
+      return null;
+    }
+  }
+
+  /**
+   * Build manifest-like config from package.json alone
+   */
+  static async buildFromPackageJson(servicePath) {
+    const packagePath = join(servicePath, 'package.json');
+    if (!existsSync(packagePath)) {
+      return null;
+    }
+    try {
+      const packageJson = JSON.parse(readFileSync(packagePath, 'utf8'));
+      return {
+        _source: 'legacy-package-only',
+        _legacyNote: 'This project has a package.json but no deployment configuration.',
+        serviceName: packageJson.name || 'unknown-service',
+        serviceType: 'nodejs-project',
+        version: packageJson.version || '1.0.0',
+        isClodoService: false,
+        isLegacyService: true,
+        deployment: {
+          framework: 'nodejs',
+          ready: false,
+          configFiles: {
+            package: './package.json'
+          }
+        },
+        metadata: {
+          detectedAt: new Date().toISOString(),
+          framework: 'legacy-nodejs'
+        }
+      };
+    } catch (err) {
+      return null;
+    }
+  }
+}
+
+/**
+ * Main manifest loader
+ */
+export class ManifestLoader {
+  /**
+   * Load service configuration with intelligent Cloudflare service validation
+   * 
+   * Returns:
+   * - Clodo Framework manifest (if found)
+   * - Validated Cloudflare service config (wrangler.toml + package.json)
+   * - Error details if not a valid Cloudflare service
+   */
+  static async loadAndValidateCloudflareService(servicePath = '.') {
+    const resolvedPath = resolve(servicePath);
+
+    // Step 1: Try loading Clodo manifest first
+    for (const location of MANIFEST_LOCATIONS) {
+      const manifestPath = join(resolvedPath, location);
+      if (existsSync(manifestPath)) {
+        try {
+          const content = readFileSync(manifestPath, 'utf8');
+          const manifest = JSON.parse(content);
+          manifest._source = 'clodo-manifest';
+          manifest._location = location;
+          manifest.isClodoService = true;
+          manifest.isValidCloudflareService = true;
+          return {
+            manifest,
+            foundAt: manifestPath,
+            isClodo: true,
+            validationResult: null
+          };
+        } catch (err) {
+          throw new Error(`Failed to parse manifest at ${manifestPath}: ${err.message}`);
+        }
+      }
+    }
+
+    // Step 2: Validate as Cloudflare service (requires wrangler.toml + package.json)
+    const validationResult = CloudflareServiceValidator.validateForDeployment(resolvedPath);
+    if (!validationResult.canDeploy && validationResult.reason === 'NOT_A_CLOUDFLARE_SERVICE') {
+      return {
+        manifest: null,
+        foundAt: null,
+        isClodo: false,
+        validationResult,
+        error: 'NOT_A_CLOUDFLARE_SERVICE'
+      };
+    }
+
+    // Step 3: Build manifest-like config from Cloudflare service
+    if (validationResult.canDeploy || validationResult.reason === 'SERVICE_VALID_WITH_WARNINGS') {
+      const manifest = this.buildFromCloudflareService(validationResult, resolvedPath);
+      return {
+        manifest,
+        foundAt: 'detected-cloudflare-service',
+        isClodo: false,
+        validationResult,
+        isValidCloudflareService: true
+      };
+    }
+
+    // Service is Cloudflare but has issues
+    return {
+      manifest: null,
+      foundAt: null,
+      isClodo: false,
+      validationResult,
+      error: 'CLOUDFLARE_SERVICE_INVALID'
+    };
+  }
+
+  /**
+   * Build manifest-like config from valid Cloudflare service files
+   */
+  static buildFromCloudflareService(validationResult, servicePath) {
+    const wranglerConfig = validationResult.validation.wranglerConfig;
+    const packageJson = validationResult.validation.packageJson;
+    return {
+      _source: 'cloudflare-service-detected',
+      _legacyNote: 'This is a Cloudflare Workers service. Consider creating it with: npx clodo-service create',
+      serviceName: packageJson.name || wranglerConfig.name || 'unknown-service',
+      serviceType: 'cloudflare-workers-service',
+      version: packageJson.version || '1.0.0',
+      isClodoService: false,
+      isValidCloudflareService: true,
+      deployment: {
+        framework: 'wrangler',
+        ready: validationResult.deploymentHistory.hasDeploymentHistory,
+        configFiles: {
+          wrangler: './wrangler.toml',
+          package: './package.json'
+        },
+        hasExistingDeployments: validationResult.deploymentHistory.hasDeploymentHistory
+      },
+      metadata: {
+        detectedAt: new Date().toISOString(),
+        framework: 'wrangler',
+        detectionReason: validationResult.reason
+      }
+    };
+  }
+
+  /**
+   * Print helpful error message for non-Cloudflare services
+   */
+  static printNotCloudflareServiceError(servicePath = '.') {
+    console.error(chalk.red('\n❌ Not a Cloudflare Workers Service\n'));
+    console.error(chalk.white('This directory is missing required Cloudflare files:'));
+    console.error(chalk.gray('  - wrangler.toml'));
+    console.error(chalk.gray('  - package.json'));
+    console.error(chalk.cyan('\n📋 To deploy, you need either:\n'));
+    console.error(chalk.white('Option 1: Create a new Clodo service'));
+    console.error(chalk.green('  npx clodo-service create'));
+    console.error(chalk.gray('  (Creates: service-manifest.json + full structure)\n'));
+    console.error(chalk.white('Option 2: Initialize an existing project'));
+    console.error(chalk.green('  npx clodo-service init'));
+    console.error(chalk.gray('  (Creates: service-manifest.json from existing files)\n'));
+    console.error(chalk.white('Option 3: Create a standard Cloudflare project'));
+    console.error(chalk.green('  npm init wrangler@latest'));
+    console.error(chalk.gray('  (Creates: wrangler.toml + package.json)\n'));
+  }
+
+  /**
+   * Print validation issues for malformed services
+   */
+  static printValidationErrors(validationResult, isClodoValidation = false) {
+    if (validationResult.validation.issues.length > 0) {
+      console.error(chalk.red('\n❌ Service Configuration Issues:\n'));
+      validationResult.validation.issues.forEach(issue => {
+        console.error(chalk.red(`  • ${issue}`));
+      });
+    }
+    if (validationResult.validation.warnings.length > 0) {
+      console.warn(chalk.yellow('\n⚠️  Service Configuration Warnings:\n'));
+      validationResult.validation.warnings.forEach(warning => {
+        console.warn(chalk.yellow(`  • ${warning}`));
+      });
+
+      // Different message based on whether this is a Clodo manifest or detected service
+      if (isClodoValidation) {
+        console.warn(chalk.cyan('\nFor Clodo manifest deployments, review these warnings before proceeding.'));
+      } else {
+        console.warn(chalk.cyan('\nThese warnings indicate optional configurations that may affect behavior.'));
+        console.warn(chalk.cyan('Deployment can proceed, but you may need to handle routing/environments in your worker code.'));
+      }
+    }
+  }
+
+  /**
+   * Validate manifest has required fields for deployment
+   */
+  static validateDeploymentReady(manifest) {
+    const errors = [];
+
+    // Required for both Clodo and legacy services
+    if (!manifest.serviceName) errors.push('Missing: serviceName');
+    if (!manifest.deployment) errors.push('Missing: deployment configuration');
+
+    // For Clodo services
+    if (manifest.isClodoService) {
+      if (!manifest.deployment.domains || manifest.deployment.domains.length === 0) {
+        errors.push('Missing: deployment.domains (required for multi-domain deployment)');
+      }
+    }
+    return {
+      isValid: errors.length === 0,
+      errors
+    };
+  }
+
+  /**
+   * Print manifest info for debugging
+   */
+  static printManifestInfo(manifest) {
+    console.log(chalk.cyan('\n📋 Service Configuration:\n'));
+    console.log(chalk.white(`Service Name: ${chalk.bold(manifest.serviceName)}`));
+    console.log(chalk.white(`Service Type: ${chalk.bold(manifest.serviceType)}`));
+    console.log(chalk.white(`Source: ${chalk.gray(manifest._source)}`));
+    if (manifest._legacyNote) {
+      console.log(chalk.yellow(`\nℹ️  ${manifest._legacyNote}`));
+    }
+    if (manifest.deployment.domains) {
+      console.log(chalk.white(`\nDomains:`));
+      manifest.deployment.domains.forEach(domain => {
+        console.log(chalk.gray(`  - ${domain.name} (${domain.environment})`));
+      });
+    }
+    console.log('');
+  }
+}
+export default ManifestLoader;

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

@@ -0,0 +1,230 @@
+/**
+ * Deployment Credential Collector
+ * 
+ * Smart credential collection for deployment:
+ * - Priority: flags → env vars → prompt → validate & auto-fetch
+ * - Uses ApiTokenManager for secure token storage
+ * - Uses CloudflareAPI for token validation and domain/zone discovery
+ * - Derives missing credentials from valid token
+ */
+
+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";
+export class DeploymentCredentialCollector {
+  constructor(options = {}) {
+    this.servicePath = options.servicePath || '.';
+    this.quiet = options.quiet || false;
+    this.tokenManager = new ApiTokenManager();
+  }
+
+  /**
+   * Collect all deployment credentials intelligently
+   * 
+   * Strategy:
+   * 1. Check for flags/env vars for all 3 credentials
+   * 2. If any missing, prompt for API token first
+   * 3. Validate API token and use it to fetch missing credentials
+   * 4. Return complete credential set
+   */
+  async collectCredentials(options = {}) {
+    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
+    };
+
+    // 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'));
+      }
+      return startCredentials;
+    }
+
+    // Need to collect interactively
+    if (!this.quiet) {
+      console.log(chalk.cyan('\n🔐 Deployment Credentials\n'));
+      console.log(chalk.white('Clodo uses a smart credential collection strategy:'));
+      console.log(chalk.gray('1. Use provided credentials if available'));
+      console.log(chalk.gray('2. Prompt for Cloudflare API token'));
+      console.log(chalk.gray('3. Auto-fetch account ID and zone ID from token'));
+      console.log(chalk.gray('4. Validate and cache credentials\n'));
+    }
+
+    // Step 1: Get/prompt for API token
+    let token = startCredentials.token;
+    if (!token) {
+      token = await this.promptForToken();
+    }
+
+    // Step 2: Validate token and get credential options
+    if (!this.quiet) {
+      console.log(chalk.cyan('\n🔍 Validating Cloudflare API token...\n'));
+    }
+    let accountId = startCredentials.accountId;
+    let zoneId = startCredentials.zoneId;
+    try {
+      const cloudflareAPI = new CloudflareAPI(token);
+
+      // Verify token is valid
+      const verification = await cloudflareAPI.verifyToken();
+      if (!verification.valid) {
+        console.error(chalk.red(`\n❌ Invalid Cloudflare API token`));
+        console.error(chalk.yellow(verification.error));
+        process.exit(1);
+      }
+      if (!this.quiet) {
+        console.log(chalk.green('✅ API token verified\n'));
+      }
+
+      // If account ID not provided, fetch from Cloudflare
+      if (!accountId) {
+        accountId = await this.fetchAccountId(cloudflareAPI);
+      }
+
+      // If zone ID not provided, fetch from Cloudflare
+      if (!zoneId) {
+        zoneId = await this.fetchZoneId(cloudflareAPI);
+      }
+    } catch (error) {
+      console.error(chalk.red(`\n❌ Credential validation failed:`));
+      console.error(chalk.yellow(error.message));
+      process.exit(1);
+    }
+    if (!this.quiet) {
+      console.log(chalk.green('\n✅ All credentials collected and validated\n'));
+    }
+    return {
+      token,
+      accountId,
+      zoneId
+    };
+  }
+
+  /**
+   * Prompt user for Cloudflare API token
+   */
+  async promptForToken() {
+    console.log(chalk.cyan('🔑 Cloudflare API Token\n'));
+    console.log(chalk.white('Your API token is used to:'));
+    console.log(chalk.gray('  • Verify your Cloudflare account'));
+    console.log(chalk.gray('  • Fetch your account ID and domains'));
+    console.log(chalk.gray('  • Deploy your service\n'));
+    console.log(chalk.cyan('💡 How to get your API token:'));
+    console.log(chalk.white('  1. Go to: https://dash.cloudflare.com/profile/api-tokens'));
+    console.log(chalk.white('  2. Click "Create Token"'));
+    console.log(chalk.white('  3. Use "Edit Cloudflare Workers" template'));
+    console.log(chalk.white('  4. Copy the token and paste it below\n'));
+
+    // Check if token exists in cache
+    if (this.tokenManager.hasToken('cloudflare')) {
+      const cached = await askUser('Use cached Cloudflare API token? (yes/no)', 'yes');
+      if (cached.toLowerCase() === 'yes' || cached.toLowerCase() === 'y') {
+        return this.tokenManager.tokens.cloudflare;
+      }
+    }
+
+    // Prompt for new token
+    const token = await askPassword('Enter your Cloudflare API token');
+    if (!token || token.trim() === '') {
+      console.error(chalk.red('❌ API token is required'));
+      process.exit(1);
+    }
+
+    // Cache the token for future use
+    this.tokenManager.tokens.cloudflare = token.trim();
+    this.tokenManager.saveTokens();
+    return token.trim();
+  }
+
+  /**
+   * Fetch account ID from Cloudflare API
+   */
+  async fetchAccountId(cloudflareAPI) {
+    try {
+      if (!this.quiet) {
+        console.log(chalk.cyan('📋 Fetching your Cloudflare account ID...\n'));
+      }
+      const response = await cloudflareAPI.request('/accounts?per_page=100');
+      const accounts = response.result || [];
+      if (accounts.length === 0) {
+        console.error(chalk.red('❌ No Cloudflare accounts found'));
+        process.exit(1);
+      }
+      if (accounts.length === 1) {
+        if (!this.quiet) {
+          console.log(chalk.green(`✅ Found account: ${accounts[0].name}\n`));
+        }
+        return accounts[0].id;
+      }
+
+      // Multiple accounts - let user choose
+      if (!this.quiet) {
+        console.log(chalk.white('Found multiple accounts:\n'));
+      }
+      const choices = accounts.map((acc, idx) => `${idx + 1}. ${acc.name} (${acc.id})`);
+      const selection = await askChoice('Select account:', choices, 0);
+      const selectedIndex = parseInt(selection.split('.')[0]) - 1;
+      const selectedAccount = accounts[selectedIndex];
+      if (!this.quiet) {
+        console.log(chalk.green(`✅ Selected: ${selectedAccount.name}\n`));
+      }
+      return selectedAccount.id;
+    } catch (error) {
+      console.error(chalk.red('❌ Failed to fetch account ID:'));
+      console.error(chalk.yellow(error.message));
+      process.exit(1);
+    }
+  }
+
+  /**
+   * Fetch zone ID from Cloudflare API
+   */
+  async fetchZoneId(cloudflareAPI) {
+    try {
+      if (!this.quiet) {
+        console.log(chalk.cyan('🌐 Fetching your Cloudflare domains...\n'));
+      }
+      const response = await cloudflareAPI.request('/zones?per_page=100');
+      const zones = response.result || [];
+      if (zones.length === 0) {
+        console.error(chalk.red('❌ No Cloudflare domains found'));
+        console.error(chalk.yellow('Please add a domain to your Cloudflare account first'));
+        process.exit(1);
+      }
+      if (zones.length === 1) {
+        if (!this.quiet) {
+          console.log(chalk.green(`✅ Found domain: ${zones[0].name}\n`));
+        }
+        return zones[0].id;
+      }
+
+      // Multiple zones - let user choose
+      if (!this.quiet) {
+        console.log(chalk.white('Found multiple domains:\n'));
+      }
+      const choices = zones.map((zone, idx) => `${idx + 1}. ${zone.name} (Status: ${zone.status})`);
+      const selection = await askChoice('Select domain for deployment:', choices, 0);
+      const selectedIndex = parseInt(selection.split('.')[0]) - 1;
+      const selectedZone = zones[selectedIndex];
+      if (!this.quiet) {
+        console.log(chalk.green(`✅ Selected: ${selectedZone.name}\n`));
+      }
+      return selectedZone.id;
+    } catch (error) {
+      console.error(chalk.red('❌ Failed to fetch domains:'));
+      console.error(chalk.yellow(error.message));
+      process.exit(1);
+    }
+  }
+
+  /**
+   * Cleanup resources
+   */
+  cleanup() {
+    closePrompts();
+  }
+}
+export default DeploymentCredentialCollector;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tamyla/clodo-framework",
-  "version": "3.1.12",
+  "version": "3.1.14",
   "description": "Reusable framework for Clodo-style software architecture on Cloudflare Workers + D1",
   "type": "module",
   "sideEffects": [