@tamyla/clodo-framework 1.0.0

package/dist/deployment/wrangler-deployer.js

@@ -0,0 +1,574 @@
+import { spawn } from 'child_process';
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * WranglerDeployer - Executes actual Cloudflare Workers deployments using wrangler CLI
+ * Provides integration between Clodo Framework orchestration and wrangler deployment
+ */
+export class WranglerDeployer {
+  constructor(options = {}) {
+    this.cwd = options.cwd || process.cwd();
+    this.configPath = options.configPath || 'wrangler.toml';
+    this.timeout = options.timeout || 300000; // 5 minutes
+    this.maxRetries = options.maxRetries || 1;
+    this.environment = options.environment || this.detectEnvironment();
+    this.serviceInfo = options.serviceInfo || this.discoverServiceInfo();
+  }
+
+  /**
+   * Detect deployment environment from various sources
+   * @returns {string} Detected environment
+   */
+  detectEnvironment() {
+    // Priority: explicit option > env var > git branch > default
+    if (process.env.NODE_ENV) return process.env.NODE_ENV;
+    if (process.env.ENVIRONMENT) return process.env.ENVIRONMENT;
+    if (process.env.CF_PAGES_BRANCH) return process.env.CF_PAGES_BRANCH;
+
+    // Try to detect from git branch
+    try {
+      const branch = execSync('git rev-parse --abbrev-ref HEAD', {
+        cwd: this.cwd
+      }).toString().trim();
+      if (branch === 'main' || branch === 'master') return 'production';
+      if (branch === 'develop' || branch === 'dev') return 'development';
+      if (branch.includes('staging')) return 'staging';
+      return 'development';
+    } catch {
+      return 'development';
+    }
+  }
+
+  /**
+   * Discover service information from project files
+   * @returns {Object} Service information
+   */
+  discoverServiceInfo() {
+    const info = {
+      name: null,
+      version: null,
+      domain: null,
+      accountId: null
+    };
+    try {
+      // Read package.json
+      const packagePath = path.join(this.cwd, 'package.json');
+      if (fs.existsSync(packagePath)) {
+        const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+        info.name = packageJson.name;
+        info.version = packageJson.version;
+      }
+
+      // Read environment variables
+      info.accountId = process.env.CLOUDFLARE_ACCOUNT_ID;
+      info.domain = process.env.SERVICE_DOMAIN || process.env.DOMAIN;
+
+      // Try to read from wrangler config
+      const configPath = path.join(this.cwd, 'wrangler.toml');
+      if (fs.existsSync(configPath)) {
+        const content = fs.readFileSync(configPath, 'utf8');
+        const accountMatch = content.match(/account_id\s*=\s*["']([^"']+)["']/);
+        if (accountMatch) {
+          info.accountId = info.accountId || accountMatch[1];
+        }
+      }
+    } catch (error) {
+      // Ignore discovery errors
+    }
+    return info;
+  }
+
+  /**
+   * Deploy worker to specified environment with intelligent configuration discovery
+   * @param {string} environment - Environment to deploy to (production, staging, development)
+   * @param {Object} options - Additional deployment options
+   * @returns {Promise<Object>} Deployment result with URL and metadata
+   */
+  async deploy(environment = 'production', options = {}) {
+    const startTime = Date.now();
+    try {
+      console.log(`   🚀 Executing wrangler deploy --env ${environment}`);
+
+      // Discover deployment configuration intelligently
+      const deployConfig = await this.discoverDeploymentConfig(environment);
+
+      // Build wrangler command arguments based on discovered config
+      const args = await this.buildWranglerCommand(environment, deployConfig, options);
+      console.log(`   📋 Command: npx ${args.join(' ')}`);
+      console.log(`   📁 Config: ${deployConfig.configPath}`);
+      console.log(`   🌍 Environment: ${environment}`);
+
+      // Execute wrangler command
+      const result = await this.executeWranglerCommand(args, {
+        cwd: this.cwd,
+        timeout: this.timeout
+      });
+      const duration = Date.now() - startTime;
+      if (result.success) {
+        // Extract deployment URL with enhanced parsing
+        const deploymentUrl = this.extractDeploymentUrl(result.output, deployConfig);
+        console.log(`   ✅ Deployment successful in ${duration}ms`);
+        console.log(`   🌐 URL: ${deploymentUrl}`);
+        return {
+          success: true,
+          url: deploymentUrl,
+          environment,
+          duration,
+          deploymentId: this.generateDeploymentId(),
+          output: result.output,
+          config: deployConfig,
+          timestamp: new Date().toISOString()
+        };
+      } else {
+        console.error(`   ❌ Deployment failed after ${duration}ms`);
+        console.error(`   Error: ${result.error}`);
+        throw new Error(`Wrangler deployment failed: ${result.error}`);
+      }
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      console.error(`   ❌ Deployment error after ${duration}ms: ${error.message}`);
+      throw new Error(`Deployment failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Execute wrangler command and capture output
+   * @param {Array<string>} args - Command arguments
+   * @param {Object} options - Execution options
+   * @returns {Promise<Object>} Command execution result
+   */
+  async executeWranglerCommand(args, options = {}) {
+    return new Promise((resolve, reject) => {
+      const child = spawn('npx', args, {
+        cwd: options.cwd || this.cwd,
+        stdio: ['inherit', 'pipe', 'pipe'],
+        shell: true,
+        timeout: options.timeout || this.timeout
+      });
+      let stdout = '';
+      let stderr = '';
+      child.stdout.on('data', data => {
+        const output = data.toString();
+        stdout += output;
+        console.log(`   ${output.trim()}`);
+      });
+      child.stderr.on('data', data => {
+        const output = data.toString();
+        stderr += output;
+        console.error(`   ${output.trim()}`);
+      });
+      child.on('close', code => {
+        const success = code === 0;
+        resolve({
+          success,
+          code,
+          output: stdout,
+          error: stderr,
+          fullOutput: stdout + stderr
+        });
+      });
+      child.on('error', error => {
+        reject(new Error(`Failed to execute wrangler: ${error.message}`));
+      });
+
+      // Handle timeout
+      if (options.timeout) {
+        setTimeout(() => {
+          child.kill('SIGTERM');
+          reject(new Error(`Wrangler command timed out after ${options.timeout}ms`));
+        }, options.timeout);
+      }
+    });
+  }
+
+  /**
+   * Extract deployment URL from wrangler output with intelligent parsing
+   * @param {string} output - Wrangler command output
+   * @param {Object} config - Deployment configuration
+   * @returns {string|null} Deployment URL or null if not found
+   */
+  extractDeploymentUrl(output, config) {
+    // Strategy 1: Look for explicit URL patterns in output
+    const urlPatterns = [/https:\/\/[^\s\n]+/g, /Deployed to:\s*(https:\/\/[^\s\n]+)/i, /Your worker has been deployed to:\s*(https:\/\/[^\s\n]+)/i, /Worker URL:\s*(https:\/\/[^\s\n]+)/i, /Available at:\s*(https:\/\/[^\s\n]+)/i];
+    for (const pattern of urlPatterns) {
+      const matches = output.match(pattern);
+      if (matches && matches.length > 0) {
+        for (const match of matches) {
+          const url = match.replace(/^.*?https:\/\//, 'https://').split(/[>\s\n]/)[0];
+          if (url.startsWith('https://') && this.isValidDeploymentUrl(url, config)) {
+            return url;
+          }
+        }
+      }
+    }
+
+    // Strategy 2: Use routes from config if available
+    if (config.routes && config.routes.length > 0) {
+      for (const route of config.routes) {
+        if (route.startsWith('https://')) {
+          return route;
+        }
+      }
+    }
+
+    // Strategy 3: Construct URL from worker name
+    if (config.workerName) {
+      // Check if it's already a full domain
+      if (config.workerName.includes('.')) {
+        return `https://${config.workerName}`;
+      }
+
+      // Construct workers.dev URL
+      return `https://${config.workerName}.workers.dev`;
+    }
+
+    // Strategy 4: Fallback URL construction from environment and output
+    const lines = output.split('\n');
+    for (const line of lines) {
+      if (line.includes('https://') && (line.includes('.workers.dev') || line.includes(config.environment) || line.includes('deployed'))) {
+        const urlMatch = line.match(/https:\/\/[^\s\n>]+/);
+        if (urlMatch) {
+          return urlMatch[0];
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Validate if a URL is a likely deployment URL
+   * @param {string} url - URL to validate
+   * @param {Object} config - Deployment config
+   * @returns {boolean} True if URL appears valid for deployment
+   */
+  isValidDeploymentUrl(url, config) {
+    try {
+      const urlObj = new URL(url);
+
+      // Must be HTTPS
+      if (urlObj.protocol !== 'https:') return false;
+
+      // Should be workers.dev or custom domain
+      const hostname = urlObj.hostname;
+      return hostname.includes('.workers.dev') || hostname.includes('.dev') || hostname.includes(config.environment) || config.workerName && hostname.includes(config.workerName);
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Generate unique deployment ID
+   * @returns {string} Unique deployment identifier
+   */
+  generateDeploymentId() {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const random = Math.random().toString(36).substring(2, 8);
+    return `deploy-${timestamp}-${random}`;
+  }
+
+  /**
+   * Intelligently discover deployment configuration for the given environment
+   * @param {string} environment - Target environment
+   * @returns {Promise<Object>} Discovered configuration
+   */
+  async discoverDeploymentConfig(environment) {
+    const config = {
+      configPath: null,
+      hasEnvironmentConfig: false,
+      workerName: null,
+      routes: [],
+      environment
+    };
+
+    // Strategy 1: Check for environment-specific wrangler.toml
+    const envConfigPath = path.join(this.cwd, 'config', 'wrangler.toml');
+    if (fs.existsSync(envConfigPath)) {
+      config.configPath = 'config/wrangler.toml';
+      config.hasEnvironmentConfig = true;
+      try {
+        // Try to parse basic config info (without TOML dependency)
+        const content = fs.readFileSync(envConfigPath, 'utf8');
+        config.workerName = this.extractWorkerNameFromConfig(content);
+        config.routes = this.extractRoutesFromConfig(content);
+      } catch (error) {
+        console.warn(`   ⚠️ Could not parse config file: ${error.message}`);
+      }
+    }
+
+    // Strategy 2: Check for root wrangler.toml
+    if (!config.configPath) {
+      const rootConfigPath = path.join(this.cwd, 'wrangler.toml');
+      if (fs.existsSync(rootConfigPath)) {
+        config.configPath = 'wrangler.toml';
+        try {
+          const content = fs.readFileSync(rootConfigPath, 'utf8');
+          config.workerName = this.extractWorkerNameFromConfig(content);
+          config.routes = this.extractRoutesFromConfig(content);
+
+          // Check if root config has environment-specific sections
+          config.hasEnvironmentConfig = content.includes(`[env.${environment}]`);
+        } catch (error) {
+          console.warn(`   ⚠️ Could not parse root config: ${error.message}`);
+        }
+      }
+    }
+
+    // Strategy 3: Fallback to package.json for worker name
+    if (!config.workerName) {
+      try {
+        const packagePath = path.join(this.cwd, 'package.json');
+        if (fs.existsSync(packagePath)) {
+          const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+          config.workerName = packageJson.name;
+        }
+      } catch (error) {
+        // Ignore package.json parsing errors
+      }
+    }
+    return config;
+  }
+
+  /**
+   * Build wrangler command arguments based on discovered configuration
+   * @param {string} environment - Target environment
+   * @param {Object} config - Discovered configuration
+   * @param {Object} options - Additional options
+   * @returns {Promise<Array<string>>} Command arguments
+   */
+  async buildWranglerCommand(environment, config, options = {}) {
+    const args = ['wrangler', 'deploy'];
+
+    // Add config path if not default
+    if (config.configPath && config.configPath !== 'wrangler.toml') {
+      args.push('--config', config.configPath);
+    }
+
+    // Add environment flag based on configuration
+    if (config.hasEnvironmentConfig) {
+      args.push('--env', environment);
+    } else if (environment !== 'production') {
+      // For non-production without explicit env config, still try
+      args.push('--env', environment);
+    }
+
+    // Add deployment options
+    if (options.dryRun) {
+      args.push('--dry-run');
+    }
+    if (options.legacyAssets) {
+      args.push('--legacy-assets');
+    }
+
+    // Add environment variables from process.env that might be relevant
+    const envVars = this.extractRelevantEnvironmentVars(environment);
+    Object.entries(envVars).forEach(([key, value]) => {
+      if (value) {
+        args.push('--var', `${key}:${value}`);
+      }
+    });
+
+    // Add any environment-specific overrides from options
+    if (options.vars) {
+      Object.entries(options.vars).forEach(([key, value]) => {
+        args.push('--var', `${key}:${value}`);
+      });
+    }
+    return args;
+  }
+
+  /**
+   * Extract worker name from wrangler config content (basic parsing)
+   * @param {string} content - Config file content
+   * @returns {string|null} Worker name or null
+   */
+  extractWorkerNameFromConfig(content) {
+    const nameMatch = content.match(/name\s*=\s*["']([^"']+)["']/);
+    return nameMatch ? nameMatch[1] : null;
+  }
+
+  /**
+   * Extract routes from wrangler config content
+   * @param {string} content - Config file content
+   * @returns {Array<string>} Routes
+   */
+  extractRoutesFromConfig(content) {
+    const routes = [];
+    const routeMatches = content.match(/route\s*=\s*["']([^"']+)["']/g);
+    if (routeMatches) {
+      routeMatches.forEach(match => {
+        const routeMatch = match.match(/route\s*=\s*["']([^"']+)["']/);
+        if (routeMatch) {
+          routes.push(routeMatch[1]);
+        }
+      });
+    }
+    return routes;
+  }
+
+  /**
+   * Extract relevant environment variables for deployment
+   * @param {string} environment - Target environment
+   * @returns {Object} Relevant environment variables
+   */
+  extractRelevantEnvironmentVars(environment) {
+    const relevantVars = {};
+
+    // Cloudflare-specific variables
+    const cfVars = ['CLOUDFLARE_ACCOUNT_ID', 'CLOUDFLARE_ZONE_ID', 'CLOUDFLARE_API_TOKEN', 'CF_API_TOKEN', 'CF_ACCOUNT_ID'];
+    cfVars.forEach(varName => {
+      if (process.env[varName]) {
+        relevantVars[varName] = process.env[varName];
+      }
+    });
+
+    // Service-specific variables
+    const serviceVars = ['SERVICE_DOMAIN', 'SERVICE_NAME', 'NODE_ENV', 'ENVIRONMENT', 'LOG_LEVEL', 'CORS_ORIGINS', 'DATA_SERVICE_URL', 'AUTH_SERVICE_URL', 'CONTENT_STORE_SERVICE_URL', 'FRONTEND_URL', 'MAGIC_LINK_EXPIRY_MINUTES', 'RATE_LIMIT_WINDOW_MS', 'RATE_LIMIT_MAX', 'MAX_FILE_SIZE', 'ALLOWED_FILE_TYPES', 'SKIP_WEBHOOK_AUTH'];
+    serviceVars.forEach(varName => {
+      if (process.env[varName]) {
+        relevantVars[varName] = process.env[varName];
+      }
+    });
+
+    // Environment-specific variables
+    const envSpecificVars = [`${environment.toUpperCase()}_URL`, `${environment.toUpperCase()}_DOMAIN`, `CF_${environment.toUpperCase()}_TOKEN`];
+    envSpecificVars.forEach(varName => {
+      if (process.env[varName]) {
+        relevantVars[varName] = process.env[varName];
+      }
+    });
+    return relevantVars;
+  }
+
+  /**
+   * Validate wrangler installation and configuration with intelligent discovery
+   * @param {string} environment - Environment to validate for
+   * @returns {Promise<Object>} Validation result with detailed configuration info
+   */
+  async validateWranglerSetup(environment = 'production') {
+    try {
+      console.log('   🔍 Validating wrangler setup...');
+
+      // Check if wrangler is available
+      const versionResult = await this.executeWranglerCommand(['wrangler', '--version']);
+      if (!versionResult.success) {
+        return {
+          valid: false,
+          error: 'Wrangler CLI not found or not working',
+          details: versionResult.error
+        };
+      }
+
+      // Discover deployment configuration
+      const deployConfig = await this.discoverDeploymentConfig(environment);
+      if (!deployConfig.configPath) {
+        return {
+          valid: false,
+          error: 'No wrangler configuration found',
+          details: 'Expected wrangler.toml or config/wrangler.toml',
+          suggestions: ['Run: wrangler init', 'Create wrangler.toml in project root', 'Create config/wrangler.toml for environment-specific config']
+        };
+      }
+
+      // Validate authentication
+      const authResult = await this.executeWranglerCommand(['wrangler', 'whoami']);
+      if (!authResult.success) {
+        return {
+          valid: false,
+          error: 'Wrangler authentication failed',
+          details: 'You need to login to Cloudflare',
+          suggestions: ['Run: wrangler auth login', 'Or set CLOUDFLARE_API_TOKEN environment variable']
+        };
+      }
+
+      // Extract account information
+      const accountInfo = this.extractAccountInfo(authResult.output);
+
+      // Validate configuration can be parsed
+      const configValidation = await this.validateWranglerConfig(deployConfig, environment);
+      return {
+        valid: true,
+        version: versionResult.output.trim(),
+        config: deployConfig,
+        account: accountInfo,
+        configValidation,
+        authenticated: true,
+        ready: configValidation.valid
+      };
+    } catch (error) {
+      return {
+        valid: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Extract account information from wrangler whoami output
+   * @param {string} output - wrangler whoami output
+   * @returns {Object} Account information
+   */
+  extractAccountInfo(output) {
+    const info = {};
+
+    // Extract email
+    const emailMatch = output.match(/(\S+@\S+\.\S+)/);
+    if (emailMatch) {
+      info.email = emailMatch[1];
+    }
+
+    // Extract account name/id
+    const accountMatch = output.match(/Account:\s*([^\n]+)/i);
+    if (accountMatch) {
+      info.account = accountMatch[1].trim();
+    }
+    return info;
+  }
+
+  /**
+   * Validate wrangler configuration for the given environment
+   * @param {Object} config - Deployment configuration
+   * @param {string} environment - Target environment
+   * @returns {Promise<Object>} Configuration validation result
+   */
+  async validateWranglerConfig(config, environment) {
+    try {
+      const args = ['wrangler', 'deploy', '--dry-run'];
+      if (config.configPath && config.configPath !== 'wrangler.toml') {
+        args.push('--config', config.configPath);
+      }
+      if (config.hasEnvironmentConfig) {
+        args.push('--env', environment);
+      }
+      const result = await this.executeWranglerCommand(args);
+      return {
+        valid: result.success,
+        error: result.success ? null : result.error,
+        warnings: this.extractConfigWarnings(result.output)
+      };
+    } catch (error) {
+      return {
+        valid: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Extract configuration warnings from wrangler output
+   * @param {string} output - Wrangler output
+   * @returns {Array<string>} Warning messages
+   */
+  extractConfigWarnings(output) {
+    const warnings = [];
+    const lines = output.split('\n');
+    for (const line of lines) {
+      if (line.includes('Warning') || line.includes('warning') || line.includes('WARN') || line.includes('⚠️')) {
+        warnings.push(line.trim());
+      }
+    }
+    return warnings;
+  }
+}
+export default WranglerDeployer;