@tamyla/clodo-framework 4.0.11 → 4.0.13

package/dist/cli/commands/assess.js

@@ -5,7 +5,8 @@
 
 import chalk from 'chalk';
 import path from 'path';
-import { ServiceOrchestrator, StandardOptions, ServiceConfigManager } from '@tamyla/clodo-framework';
+import { ServiceOrchestrator, ServiceConfigManager } from '@tamyla/clodo-framework';
+import { StandardOptions } from '../../lib/shared/utils/cli-options.js';
 export function registerAssessCommand(program) {
   const command = program.command('assess [service-path]').description('Run intelligent capability assessment (requires @tamyla/clodo-orchestration)').option('--export <file>', 'Export assessment results to JSON file').option('--domain <domain>', 'Domain name for assessment').option('--service-type <type>', 'Service type for assessment').option('--token <token>', 'Cloudflare API token').option('--show-config-sources', 'Display all configuration sources and merged result');
 

package/dist/cli/commands/create.js

@@ -6,7 +6,8 @@
  */
 
 import chalk from 'chalk';
-import { Clodo, StandardOptions, ConfigLoader } from '@tamyla/clodo-framework';
+import { Clodo, ConfigLoader } from '@tamyla/clodo-framework';
+import { StandardOptions } from '../../lib/shared/utils/cli-options.js';
 export function registerCreateCommand(program) {
   const command = program.command('create').description('Create a new Clodo service with conversational setup').option('-n, --non-interactive', 'Run in non-interactive mode with all required parameters').option('--service-name <name>', 'Service name (required in non-interactive mode)').option('--service-type <type>', 'Service type: data-service, auth-service, content-service, api-gateway, generic', 'generic').option('--domain-name <domain>', 'Domain name (required in non-interactive mode)').option('--cloudflare-token <token>', 'Cloudflare API token (required in non-interactive mode)').option('--cloudflare-account-id <id>', 'Cloudflare account ID (required in non-interactive mode)').option('--cloudflare-zone-id <id>', 'Cloudflare zone ID (required in non-interactive mode)').option('--environment <env>', 'Target environment: development, staging, production', 'development').option('--output-path <path>', 'Output directory for generated service', '.').option('--template-path <path>', 'Path to service templates', './templates').option('--force', 'Skip confirmation prompts').option('--validate', 'Validate service after creation');
 

package/dist/cli/commands/deploy.js

@@ -1,5 +1,6 @@
 import chalk from 'chalk';
-import { Clodo, StandardOptions, ConfigLoader, InteractiveDeploymentCoordinator, OutputFormatter } from '@tamyla/clodo-framework';
+import { Clodo, ConfigLoader, InteractiveDeploymentCoordinator, OutputFormatter } from '@tamyla/clodo-framework';
+import { StandardOptions } from '../../lib/shared/utils/cli-options.js';
 export function registerDeployCommand(program) {
   const command = program.command('deploy').description('Deploy a Clodo service with interactive configuration and validation')
   // Cloudflare-specific options

package/dist/cli/commands/diagnose.js

@@ -1,6 +1,7 @@
 import chalk from 'chalk';
 import path from 'path';
-import { ServiceOrchestrator, StandardOptions, ServiceConfigManager } from '@tamyla/clodo-framework';
+import { ServiceOrchestrator, ServiceConfigManager } from '@tamyla/clodo-framework';
+import { StandardOptions } from '../../lib/shared/utils/cli-options.js';
 export function registerDiagnoseCommand(program) {
   const command = program.command('diagnose [service-path]').description('Diagnose and report issues with an existing service').option('--deep-scan', 'Perform deep analysis including dependencies and deployment readiness').option('--export-report <file>', 'Export diagnostic report to file').option('--fix-suggestions', 'Include suggested fixes for issues').option('--show-config-sources', 'Display all configuration sources and merged result');
 

package/dist/cli/commands/update.js

@@ -4,7 +4,8 @@
 
 import chalk from 'chalk';
 import path from 'path';
-import { ServiceOrchestrator, StandardOptions, ServiceConfigManager } from '@tamyla/clodo-framework';
+import { ServiceOrchestrator, ServiceConfigManager } from '@tamyla/clodo-framework';
+import { StandardOptions } from '../../lib/shared/utils/cli-options.js';
 export function registerUpdateCommand(program) {
   const command = program.command('update [service-path]').description('Update an existing service configuration').option('-i, --interactive', 'Run in interactive mode to select what to update').option('--domain-name <domain>', 'Update domain name').option('--cloudflare-token <token>', 'Update Cloudflare API token').option('--cloudflare-account-id <id>', 'Update Cloudflare account ID').option('--cloudflare-zone-id <id>', 'Update Cloudflare zone ID').option('--environment <env>', 'Update target environment: development, staging, production').option('--add-feature <feature>', 'Add a feature flag').option('--remove-feature <feature>', 'Remove a feature flag').option('--regenerate-configs', 'Regenerate all configuration files').option('--fix-errors', 'Attempt to fix common configuration errors').option('--preview', 'Show what would be changed without applying').option('--show-config-sources', 'Display all configuration sources and merged result').option('--force', 'Skip confirmation prompts');
 

package/dist/cli/commands/validate.js

@@ -1,5 +1,6 @@
 import chalk from 'chalk';
-import { Clodo, StandardOptions } from '@tamyla/clodo-framework';
+import { Clodo } from '@tamyla/clodo-framework';
+import { StandardOptions } from '../../lib/shared/utils/cli-options.js';
 export function registerValidateCommand(program) {
   const command = program.command('validate <service-path>').description('Validate an existing service configuration').option('--export-report <file>', 'Export validation report to JSON file');
 

package/dist/deployment/wrangler-deployer.js

@@ -2,7 +2,7 @@ import { spawn } from 'child_process';
 import { execSync } from 'child_process';
 import fs from 'fs';
 import path from 'path';
-import { WranglerD1Manager } from '../../lib/database/wrangler-d1-manager.js';
+import { WranglerD1Manager } from '../lib/database/wrangler-d1-manager.js';
 
 /**
  * WranglerDeployer - Executes actual Cloudflare Workers deployments using wrangler CLI

package/dist/lib/shared/utils/configuration-validator.js

@@ -0,0 +1,250 @@
+/**
+ * Configuration Validator
+ *
+ * Validates service configurations before deployment to catch issues early
+ * and provide actionable error messages.
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { WranglerCompatibilityDetector } from './wrangler-compatibility.js';
+export class ConfigurationValidator {
+  /**
+   * Validate a service configuration
+   * @param {string} servicePath - Path to the service directory
+   * @returns {Promise<ValidationResult>} Validation result
+   */
+  static async validateServiceConfig(servicePath) {
+    const result = {
+      isValid: true,
+      errors: [],
+      warnings: [],
+      suggestions: []
+    };
+    try {
+      // Check if wrangler.toml exists
+      const wranglerPath = join(servicePath, 'wrangler.toml');
+      if (!existsSync(wranglerPath)) {
+        result.isValid = false;
+        result.errors.push('Missing wrangler.toml file');
+        result.suggestions.push('Run: npx clodo-service create --service-name <name>');
+        return result;
+      }
+
+      // Load and parse wrangler.toml
+      const wranglerConfig = ConfigurationValidator.parseWranglerToml(wranglerPath);
+      if (!wranglerConfig) {
+        result.isValid = false;
+        result.errors.push('Invalid wrangler.toml format');
+        return result;
+      }
+
+      // Validate required fields
+      ConfigurationValidator.validateRequiredFields(wranglerConfig, result);
+
+      // Validate compatibility configuration
+      await ConfigurationValidator.validateCompatibilityConfig(wranglerConfig, result);
+
+      // Validate build configuration
+      ConfigurationValidator.validateBuildConfig(wranglerConfig, result);
+
+      // Check for common issues
+      ConfigurationValidator.checkCommonIssues(servicePath, wranglerConfig, result);
+    } catch (error) {
+      result.isValid = false;
+      result.errors.push(`Configuration validation failed: ${error.message}`);
+    }
+    return result;
+  }
+
+  /**
+   * Parse wrangler.toml file
+   * @param {string} filePath - Path to wrangler.toml
+   * @returns {Object|null} Parsed configuration or null if invalid
+   */
+  static parseWranglerToml(filePath) {
+    try {
+      const content = readFileSync(filePath, 'utf8');
+      // Simple TOML-like parsing (basic implementation)
+      const config = {};
+      const lines = content.split('\n').map(line => line.trim()).filter(line => line && !line.startsWith('#'));
+      let currentSection = null;
+      for (const line of lines) {
+        if (line.startsWith('[') && line.endsWith(']')) {
+          currentSection = line.slice(1, -1);
+          config[currentSection] = {};
+        } else if (line.includes('=')) {
+          const [key, ...valueParts] = line.split('=');
+          const value = valueParts.join('=').trim();
+          if (currentSection) {
+            config[currentSection][key.trim()] = this.parseValue(value);
+          } else {
+            config[key.trim()] = this.parseValue(value);
+          }
+        }
+      }
+      return config;
+    } catch (error) {
+      console.warn(`Failed to parse wrangler.toml: ${error.message}`);
+      return null;
+    }
+  }
+
+  /**
+   * Parse TOML value
+   * @param {string} value - Raw value string
+   * @returns {any} Parsed value
+   */
+  static parseValue(value) {
+    // Remove quotes
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      return value.slice(1, -1);
+    }
+
+    // Parse booleans
+    if (value === 'true') return true;
+    if (value === 'false') return false;
+
+    // Parse arrays (basic)
+    if (value.startsWith('[') && value.endsWith(']')) {
+      try {
+        return JSON.parse(value);
+      } catch {
+        return value;
+      }
+    }
+    return value;
+  }
+
+  /**
+   * Validate required fields
+   * @param {Object} config - Wrangler configuration
+   * @param {ValidationResult} result - Validation result to update
+   */
+  static validateRequiredFields(config, result) {
+    const required = ['name', 'main', 'compatibility_date', 'account_id'];
+    for (const field of required) {
+      if (!config[field]) {
+        result.isValid = false;
+        result.errors.push(`Missing required field: ${field}`);
+      }
+    }
+
+    // Check for D1 databases
+    if (config['d1_databases'] || config['[[d1_databases]]']) {
+      if (!config['d1_databases']?.binding || !config['[[d1_databases]]']?.binding) {
+        result.warnings.push('D1 database configured but binding not specified');
+      }
+    }
+  }
+
+  /**
+   * Validate compatibility configuration
+   * @param {Object} config - Wrangler configuration
+   * @param {ValidationResult} result - Validation result to update
+   */
+  static async validateCompatibilityConfig(config, result) {
+    try {
+      const detector = new WranglerCompatibilityDetector();
+      const wranglerVersion = await Promise.race([detector.detectVersion(), new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout')), 2000))]);
+      const optimalConfig = detector.getOptimalConfig(wranglerVersion);
+
+      // Check if current config matches optimal
+      if (optimalConfig.nodejs_compat !== undefined) {
+        if (config.nodejs_compat !== optimalConfig.nodejs_compat) {
+          result.warnings.push(`nodejs_compat should be ${optimalConfig.nodejs_compat} for Wrangler ${wranglerVersion}`);
+          result.suggestions.push('Consider updating compatibility configuration');
+        }
+      } else if (optimalConfig.compatibility_flags) {
+        const currentFlags = config.compatibility_flags;
+        if (!currentFlags || !Array.isArray(currentFlags) || !ConfigurationValidator.arraysEqual(currentFlags, optimalConfig.compatibility_flags)) {
+          result.warnings.push(`compatibility_flags should be ${JSON.stringify(optimalConfig.compatibility_flags)} for Wrangler ${wranglerVersion}`);
+          result.suggestions.push('Consider updating compatibility configuration');
+        }
+      }
+    } catch (error) {
+      result.warnings.push(`Could not validate compatibility configuration: ${error.message}`);
+    }
+  }
+
+  /**
+   * Validate build configuration
+   * @param {Object} config - Wrangler configuration
+   * @param {ValidationResult} result - Validation result to update
+   */
+  static validateBuildConfig(config, result) {
+    const build = config.build || {};
+
+    // Check for build command
+    if (!build.command) {
+      result.warnings.push('No build command specified - deployment may fail if code needs compilation');
+      result.suggestions.push('Add: [build] command = "npm run build"');
+    }
+
+    // Check for upload format
+    const upload = build.upload || {};
+    if (!upload.format) {
+      result.warnings.push('No upload format specified - using default may cause issues');
+      result.suggestions.push('Add: [build.upload] format = "modules"');
+    }
+
+    // Check for external includes (important for Node.js modules)
+    const external = upload.external || {};
+    if (!external.include || !external.include.includes('node:*')) {
+      result.warnings.push('Node.js modules may not be properly externalized');
+      result.suggestions.push('Add: [build.upload.external] include = ["node:*"]');
+    }
+  }
+
+  /**
+   * Check for common configuration issues
+   * @param {string} servicePath - Service directory path
+   * @param {Object} config - Wrangler configuration
+   * @param {ValidationResult} result - Validation result to update
+   */
+  static checkCommonIssues(servicePath, config, result) {
+    // Check if main file exists
+    if (config.main) {
+      const mainPath = join(servicePath, config.main);
+      if (!existsSync(mainPath)) {
+        result.isValid = false;
+        result.errors.push(`Main file does not exist: ${config.main}`);
+        result.suggestions.push('Ensure the main file exists or update the main field in wrangler.toml');
+      }
+    }
+
+    // Check for environment variables without values
+    const vars = config.vars || {};
+    for (const [key, value] of Object.entries(vars)) {
+      if (value === '' || value === '""') {
+        result.warnings.push(`Environment variable ${key} has empty value`);
+      }
+    }
+
+    // Check for database_id placeholders
+    if (config['d1_databases']?.database_id === '') {
+      result.warnings.push('D1 database_id is empty - needs to be configured before deployment');
+      result.suggestions.push('Run: wrangler d1 create <database-name>');
+    }
+  }
+
+  /**
+   * Check if two arrays are equal
+   * @param {Array} a - First array
+   * @param {Array} b - Second array
+   * @returns {boolean} True if arrays are equal
+   */
+  static arraysEqual(a, b) {
+    if (a.length !== b.length) return false;
+    return a.every((val, index) => val === b[index]);
+  }
+}
+
+/**
+ * Validation result interface
+ * @typedef {Object} ValidationResult
+ * @property {boolean} isValid - Whether configuration is valid
+ * @property {string[]} errors - Critical errors that prevent deployment
+ * @property {string[]} warnings - Non-critical issues that should be addressed
+ * @property {string[]} suggestions - Actionable suggestions for improvement
+ */

package/dist/lib/shared/utils/wrangler-compatibility.js

@@ -0,0 +1,191 @@
+/**
+ * Wrangler Compatibility Detector
+ *
+ * Automatically detects Wrangler version and provides optimal configuration
+ * to prevent deployment failures due to compatibility issues.
+ */
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+
+/**
+ * Wrangler Compatibility Detector
+ * Handles version detection and optimal configuration generation
+ */
+export class WranglerCompatibilityDetector {
+  /**
+   * Detects the installed Wrangler version
+   * @returns {Promise<string>} Wrangler version string
+   */
+  async detectVersion() {
+    try {
+      const {
+        stdout
+      } = await execAsync('npx wrangler --version');
+      const version = stdout.trim();
+
+      // Validate version format (e.g., "3.15.0", "4.0.0")
+      if (!this.isValidVersion(version)) {
+        console.warn(`⚠️  Detected Wrangler version '${version}' may not be valid. Using fallback detection.`);
+        return this.fallbackDetection();
+      }
+      return version;
+    } catch (error) {
+      console.warn(`⚠️  Failed to detect Wrangler version: ${error.message}`);
+      return this.fallbackDetection();
+    }
+  }
+
+  /**
+   * Validates version string format
+   * @param {string} version - Version string to validate
+   * @returns {boolean} True if version format is valid
+   */
+  isValidVersion(version) {
+    // Match semantic versioning (e.g., 3.15.0, 4.0.0-beta.1)
+    const versionRegex = /^\d+\.\d+\.\d+(-[\w\.\-]+)?$/;
+    return versionRegex.test(version);
+  }
+
+  /**
+   * Fallback version detection when direct detection fails
+   * @returns {string} Fallback version string
+   */
+  fallbackDetection() {
+    // Check for wrangler in package.json
+    try {
+      const fs = require('fs');
+      const path = require('path');
+
+      // Look for wrangler in package.json
+      const packagePath = path.join(process.cwd(), 'package.json');
+      if (fs.existsSync(packagePath)) {
+        const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+        const wranglerVersion = packageJson.dependencies?.wrangler || packageJson.devDependencies?.wrangler;
+        if (wranglerVersion) {
+          // Extract version from semver range (e.g., "^3.15.0" -> "3.15.0")
+          const cleanVersion = wranglerVersion.replace(/[^\d.]/g, '');
+          if (cleanVersion) {
+            console.log(`📋 Using Wrangler version from package.json: ${cleanVersion}`);
+            return cleanVersion;
+          }
+        }
+      }
+    } catch (error) {
+      console.warn(`⚠️  Fallback detection failed: ${error.message}`);
+    }
+
+    // Default to latest stable version
+    console.log('📋 Using default Wrangler version: 4.0.0');
+    return '4.0.0';
+  }
+
+  /**
+   * Gets optimal Wrangler configuration for the detected version
+   * @param {string} version - Wrangler version
+   * @returns {Object} Optimal configuration object
+   */
+  getOptimalConfig(version) {
+    const majorVersion = parseInt(version.split('.')[0]);
+    if (majorVersion >= 4) {
+      // Wrangler v4+ uses nodejs_compat flag
+      return {
+        nodejs_compat: true
+      };
+    } else if (majorVersion >= 3) {
+      // Wrangler v3 uses compatibility_flags array
+      return {
+        compatibility_flags: ["nodejs_compat"]
+      };
+    } else {
+      // Wrangler v2 and below - minimal compatibility
+      return {
+        compatibility_flags: []
+      };
+    }
+  }
+
+  /**
+   * Gets build configuration optimized for the Wrangler version
+   * @param {string} version - Wrangler version
+   * @returns {Object} Build configuration object
+   */
+  getBuildConfig(version) {
+    const majorVersion = parseInt(version.split('.')[0]);
+    const baseConfig = {
+      command: "npm run build",
+      upload: {
+        format: "modules"
+      }
+    };
+
+    // Add Node.js module externalization for v3+
+    if (majorVersion >= 3) {
+      baseConfig.upload.external = {
+        include: ["node:*"]
+      };
+    }
+    return baseConfig;
+  }
+
+  /**
+   * Validates if current configuration is optimal for the Wrangler version
+   * @param {Object} config - Current Wrangler configuration
+   * @param {string} version - Wrangler version
+   * @returns {Object} Validation result with issues and suggestions
+   */
+  validateConfig(config, version) {
+    const issues = [];
+    const optimalConfig = this.getOptimalConfig(version);
+
+    // Check Node.js compatibility settings
+    if (optimalConfig.nodejs_compat !== undefined) {
+      if (config.nodejs_compat !== optimalConfig.nodejs_compat) {
+        issues.push({
+          type: 'COMPATIBILITY_CONFIG',
+          severity: 'ERROR',
+          message: `nodejs_compat should be ${optimalConfig.nodejs_compat} for Wrangler ${version}`,
+          fix: `Set nodejs_compat = ${optimalConfig.nodejs_compat} in wrangler.toml`
+        });
+      }
+    } else if (optimalConfig.compatibility_flags) {
+      const hasNodejsCompat = config.compatibility_flags?.includes('nodejs_compat');
+      const shouldHaveNodejsCompat = optimalConfig.compatibility_flags.includes('nodejs_compat');
+      if (hasNodejsCompat !== shouldHaveNodejsCompat) {
+        issues.push({
+          type: 'COMPATIBILITY_FLAGS',
+          severity: 'ERROR',
+          message: `compatibility_flags should ${shouldHaveNodejsCompat ? 'include' : 'exclude'} "nodejs_compat" for Wrangler ${version}`,
+          fix: shouldHaveNodejsCompat ? 'Add "nodejs_compat" to compatibility_flags array' : 'Remove "nodejs_compat" from compatibility_flags array'
+        });
+      }
+    }
+    return {
+      isValid: issues.filter(issue => issue.severity === 'ERROR').length === 0,
+      issues
+    };
+  }
+
+  /**
+   * Generates a complete optimized Wrangler configuration
+   * @param {string} version - Wrangler version
+   * @param {Object} baseConfig - Base configuration to extend
+   * @returns {Object} Complete optimized configuration
+   */
+  generateOptimalConfig(version, baseConfig = {}) {
+    const optimalConfig = this.getOptimalConfig(version);
+    const buildConfig = this.getBuildConfig(version);
+    return {
+      ...baseConfig,
+      ...optimalConfig,
+      build: {
+        ...buildConfig,
+        ...(baseConfig.build || {})
+      }
+    };
+  }
+}
+
+// Export singleton instance for convenience
+export const wranglerCompatibility = new WranglerCompatibilityDetector();