@tamyla/clodo-framework 3.1.13 → 3.1.14

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [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)
 
 

package/dist/bin/commands/deploy.js

@@ -4,7 +4,8 @@
  * Input Strategy: SMART MINIMAL
  * - Detects Clodo services OR legacy services (wrangler.toml)
  * - Supports multiple manifest locations
- * - Gathers credentials smartly: env vars → flags → fail with helpful message
+ * - 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
  */
 
@@ -12,6 +13,7 @@ import chalk from 'chalk';
 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 {
@@ -24,7 +26,8 @@ export function registerDeployCommand(program) {
         if (serviceConfig.error === 'NOT_A_CLOUDFLARE_SERVICE') {
           ManifestLoader.printNotCloudflareServiceError(servicePath);
         } else if (serviceConfig.error === 'CLOUDFLARE_SERVICE_INVALID') {
-          ManifestLoader.printValidationErrors(serviceConfig.validationResult);
+          // Pass false because we're validating a detected service, not a Clodo manifest
+          ManifestLoader.printValidationErrors(serviceConfig.validationResult, false);
         }
         process.exit(1);
       }
@@ -36,60 +39,60 @@ export function registerDeployCommand(program) {
       ManifestLoader.printManifestInfo(serviceConfig.manifest);
       console.log(chalk.gray(`Configuration loaded from: ${serviceConfig.foundAt}\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
-      };
-
-      // 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 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) {
-        console.error(chalk.red('❌ No domains configured in service manifest'));
-        console.error(chalk.yellow('Add domain configuration to: clodo-service-manifest.json'));
-        process.exit(1);
+      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

@@ -73,11 +73,9 @@ export class CloudflareServiceValidator {
         warnings.push('wrangler.toml: No environments configured (production, staging, etc)');
       }
 
-      // Check for routes configuration
-      const routes = wranglerConfig.routes;
-      if (!routes) {
-        warnings.push('wrangler.toml: No routes defined (service may not be accessible)');
-      }
+      // 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,

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

@@ -226,7 +226,7 @@ export class ManifestLoader {
   /**
    * Print validation issues for malformed services
    */
-  static printValidationErrors(validationResult) {
+  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 => {
@@ -238,7 +238,14 @@ export class ManifestLoader {
       validationResult.validation.warnings.forEach(warning => {
         console.warn(chalk.yellow(`  • ${warning}`));
       });
-      console.warn(chalk.cyan('\nContinue with deployment? (May fail or behave unexpectedly)'));
+
+      // 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.'));
+      }
     }
   }
 

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.13",
+  "version": "3.1.14",
   "description": "Reusable framework for Clodo-style software architecture on Cloudflare Workers + D1",
   "type": "module",
   "sideEffects": [