@salte-common/terraflow 0.1.0-alpha.1

package/dist/core/terraform.js

@@ -0,0 +1,247 @@
+"use strict";
+/**
+ * Terraform executor
+ * Executes terraform commands with proper environment setup
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerraformExecutor = void 0;
+const child_process_1 = require("child_process");
+const logger_1 = require("../utils/logger");
+const validator_1 = require("./validator");
+const environment_1 = require("./environment");
+const plugin_loader_1 = require("./plugin-loader");
+const backend_state_1 = require("./backend-state");
+const errors_1 = require("./errors");
+/**
+ * Terraform executor for running terraform commands
+ */
+class TerraformExecutor {
+    /**
+     * Execute full terraform workflow
+     * @param command - Terraform command (e.g., 'plan', 'apply', 'destroy')
+     * @param args - Additional terraform arguments
+     * @param config - Terraflow configuration
+     * @param context - Execution context
+     * @param options - Execution options
+     */
+    static async execute(command, args, config, context, options = {}) {
+        // 1. Run validations
+        logger_1.Logger.info('🔍 Running validations...');
+        const validationResult = await validator_1.Validator.validate(command, config, context, {
+            skipCommitCheck: options.skipCommitCheck || config['skip-commit-check'] || false,
+            dryRun: options.dryRun || false,
+        });
+        if (!validationResult.passed) {
+            logger_1.Logger.error('Validation failed:');
+            for (const error of validationResult.errors) {
+                logger_1.Logger.error(`  - ${error}`);
+            }
+            if (validationResult.warnings.length > 0) {
+                logger_1.Logger.warn('Warnings:');
+                for (const warning of validationResult.warnings) {
+                    logger_1.Logger.warn(`  - ${warning}`);
+                }
+            }
+            throw new errors_1.ConfigError('Validation failed');
+        }
+        if (validationResult.warnings.length > 0) {
+            for (const warning of validationResult.warnings) {
+                logger_1.Logger.warn(warning);
+            }
+        }
+        logger_1.Logger.info('✅ All validations passed');
+        // 2. Setup environment
+        logger_1.Logger.info('🔧 Setting up environment...');
+        const updatedContext = await environment_1.EnvironmentSetup.setup(config, context);
+        logger_1.Logger.info('✅ Environment setup complete');
+        // 3. Detect backend migration
+        if (config.backend) {
+            const previousBackendType = (0, backend_state_1.detectBackendMigration)(updatedContext.workingDir, config.backend);
+            if (previousBackendType && previousBackendType !== config.backend.type) {
+                logger_1.Logger.warn(`⚠️  Backend changed from '${previousBackendType}' to '${config.backend.type}'. Terraform will prompt to migrate state.`);
+            }
+        }
+        // 4. Execute auth plugin (if configured)
+        if (config.auth?.assume_role ||
+            config.auth?.service_principal ||
+            config.auth?.service_account) {
+            logger_1.Logger.info('🔐 Authenticating...');
+            try {
+                let authPlugin;
+                if (config.auth.assume_role) {
+                    authPlugin = await (0, plugin_loader_1.loadAuthPlugin)('aws-assume-role');
+                }
+                else if (config.auth.service_principal) {
+                    authPlugin = await (0, plugin_loader_1.loadAuthPlugin)('azure-service-principal');
+                }
+                else if (config.auth.service_account) {
+                    authPlugin = await (0, plugin_loader_1.loadAuthPlugin)('gcp-service-account');
+                }
+                if (authPlugin) {
+                    await authPlugin.validate(config.auth);
+                    const credentials = await authPlugin.authenticate(config.auth, updatedContext);
+                    // Set credentials as environment variables
+                    for (const key in credentials) {
+                        if (Object.prototype.hasOwnProperty.call(credentials, key)) {
+                            process.env[key] = credentials[key];
+                        }
+                    }
+                    logger_1.Logger.info('✅ Authentication successful');
+                }
+            }
+            catch (error) {
+                logger_1.Logger.error(`Authentication failed: ${error instanceof Error ? error.message : String(error)}`);
+                throw error;
+            }
+        }
+        // 5. Execute secrets plugin (if configured)
+        if (config.secrets) {
+            logger_1.Logger.info(`🔑 Fetching secrets from ${config.secrets.provider}...`);
+            try {
+                const secretsPlugin = await (0, plugin_loader_1.loadSecretsPlugin)(config.secrets.provider);
+                await secretsPlugin.validate(config.secrets);
+                const secrets = await secretsPlugin.getSecrets(config.secrets, updatedContext);
+                // Set secrets as environment variables (already prefixed with TF_VAR_)
+                for (const key in secrets) {
+                    if (Object.prototype.hasOwnProperty.call(secrets, key)) {
+                        process.env[key] = secrets[key];
+                    }
+                }
+                logger_1.Logger.info(`✅ Loaded ${Object.keys(secrets).length} Terraform variables from secrets`);
+            }
+            catch (error) {
+                logger_1.Logger.error(`Failed to fetch secrets: ${error instanceof Error ? error.message : String(error)}`);
+                throw error;
+            }
+        }
+        // 6. Execute backend plugin
+        const backendType = config.backend?.type || 'local';
+        logger_1.Logger.info(`📦 Configuring ${backendType} backend...`);
+        try {
+            const backendPlugin = await (0, plugin_loader_1.loadBackendPlugin)(backendType);
+            await backendPlugin.validate(config.backend || { type: 'local' });
+            // Optional setup hook
+            if (backendPlugin.setup) {
+                await backendPlugin.setup(config.backend || { type: 'local' }, updatedContext);
+            }
+            const backendArgs = await backendPlugin.getBackendConfig(config.backend || { type: 'local' }, updatedContext);
+            // Save backend state for migration detection
+            if (config.backend) {
+                (0, backend_state_1.saveBackendState)(updatedContext.workingDir, config.backend);
+            }
+            if (options.dryRun) {
+                logger_1.Logger.info('🔍 DRY RUN MODE - Terraform commands will not be executed');
+                logger_1.Logger.info('═══════════════════════════════════════════════════════');
+                logger_1.Logger.info('Would execute:');
+                logger_1.Logger.info('═══════════════════════════════════════════════════════');
+                logger_1.Logger.info(`Workspace:        ${updatedContext.workspace}`);
+                logger_1.Logger.info(`Working dir:      ${updatedContext.workingDir}`);
+                logger_1.Logger.info(`Backend:          ${backendType}`);
+                if (backendArgs.length > 0) {
+                    logger_1.Logger.info('Backend init args:');
+                    for (const arg of backendArgs) {
+                        logger_1.Logger.info(`  ${arg}`);
+                    }
+                }
+                logger_1.Logger.info(`Terraform command: terraform ${command} ${args.join(' ')}`);
+                logger_1.Logger.info('═══════════════════════════════════════════════════════');
+            }
+            else {
+                // 7. Run terraform init with backend config
+                await TerraformExecutor.init(backendType, backendArgs, updatedContext.workingDir);
+                // 8. Select/create workspace
+                await TerraformExecutor.workspace(updatedContext.workspace, updatedContext.workingDir);
+                // 9. Execute terraform command
+                await TerraformExecutor.runCommand(command, args, updatedContext.workingDir);
+            }
+        }
+        catch (error) {
+            logger_1.Logger.error(`Backend setup failed: ${error instanceof Error ? error.message : String(error)}`);
+            throw error;
+        }
+    }
+    /**
+     * Initialize terraform with backend configuration
+     * For local backend, runs terraform init without backend-config flags
+     * @param backendType - Backend type (e.g., 'local', 's3', 'azurerm', 'gcs')
+     * @param backendArgs - Backend configuration arguments (-backend-config flags)
+     * @param workingDir - Terraform working directory
+     */
+    static async init(backendType, backendArgs, workingDir) {
+        const args = ['init'];
+        // For local backend, skip backend-config arguments
+        // Terraform uses local backend by default if no backend is configured
+        if (backendType !== 'local' && backendArgs.length > 0) {
+            args.push(...backendArgs);
+        }
+        try {
+            logger_1.Logger.debug(`Executing: terraform ${args.join(' ')} in ${workingDir}`);
+            (0, child_process_1.execSync)(`terraform ${args.join(' ')}`, {
+                cwd: workingDir,
+                stdio: 'inherit',
+                encoding: 'utf8',
+            });
+            logger_1.Logger.info('✅ Terraform initialized successfully');
+        }
+        catch (error) {
+            logger_1.Logger.error(`Failed to initialize Terraform: ${error instanceof Error ? error.message : String(error)}`);
+            throw error;
+        }
+    }
+    /**
+     * Select or create workspace
+     * @param workspaceName - Workspace name
+     * @param workingDir - Terraform working directory
+     */
+    static async workspace(workspaceName, workingDir) {
+        try {
+            // Try to select existing workspace
+            logger_1.Logger.debug(`Selecting workspace: ${workspaceName}`);
+            (0, child_process_1.execSync)(`terraform workspace select ${workspaceName}`, {
+                cwd: workingDir,
+                stdio: 'pipe',
+                encoding: 'utf8',
+            });
+            logger_1.Logger.debug(`Workspace ${workspaceName} selected`);
+        }
+        catch {
+            // Workspace doesn't exist, create it
+            try {
+                logger_1.Logger.debug(`Creating workspace: ${workspaceName}`);
+                (0, child_process_1.execSync)(`terraform workspace new ${workspaceName}`, {
+                    cwd: workingDir,
+                    stdio: 'inherit',
+                    encoding: 'utf8',
+                });
+                logger_1.Logger.info(`✅ Workspace ${workspaceName} created and selected`);
+            }
+            catch (error) {
+                logger_1.Logger.error(`Failed to create workspace ${workspaceName}: ${error instanceof Error ? error.message : String(error)}`);
+                throw error;
+            }
+        }
+    }
+    /**
+     * Execute terraform command
+     * @param command - Terraform command (e.g., 'plan', 'apply', 'destroy')
+     * @param args - Additional terraform arguments
+     * @param workingDir - Terraform working directory
+     */
+    static async runCommand(command, args, workingDir) {
+        const terraformArgs = [command, ...args];
+        try {
+            logger_1.Logger.info(`🚀 Executing: terraform ${terraformArgs.join(' ')}`);
+            (0, child_process_1.execSync)(`terraform ${terraformArgs.join(' ')}`, {
+                cwd: workingDir,
+                stdio: 'inherit',
+                encoding: 'utf8',
+            });
+        }
+        catch (error) {
+            logger_1.Logger.error(`Terraform command failed: ${error instanceof Error ? error.message : String(error)}`);
+            throw error;
+        }
+    }
+}
+exports.TerraformExecutor = TerraformExecutor;
+//# sourceMappingURL=terraform.js.map

package/dist/core/validator.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Validation engine
+ * Validates configuration, workspace, and environment
+ */
+import type { TerraflowConfig, ValidationConfig } from '../types/config';
+import type { ExecutionContext } from '../types/context';
+/**
+ * Command categories for validation
+ */
+export declare const FULL_VALIDATION_COMMANDS: string[];
+export declare const BACKEND_REQUIRED_COMMANDS: string[];
+export declare const MINIMAL_VALIDATION_COMMANDS: string[];
+/**
+ * Validation result
+ */
+export interface ValidationResult {
+    passed: boolean;
+    errors: string[];
+    warnings: string[];
+}
+/**
+ * Validation engine for Terraflow
+ */
+export declare class Validator {
+    /**
+     * Validate terraform is installed and accessible
+     * @throws {ValidationError} If terraform is not installed
+     */
+    static validateTerraformInstalled(): Promise<void>;
+    /**
+     * Check if git is available (not fatal if missing)
+     * @returns True if git is available
+     */
+    static validateGitRepo(cwd?: string): Promise<boolean>;
+    /**
+     * Validate git working directory is clean (no uncommitted changes)
+     * @param cwd - Current working directory
+     * @throws {ValidationError} If working directory is not clean
+     */
+    static validateGitCommit(cwd?: string): Promise<void>;
+    /**
+     * Validate workspace name matches terraform naming rules
+     * Must match: /^[a-zA-Z0-9_-]+$/
+     * @param workspace - Workspace name to validate
+     * @throws {ValidationError} If workspace name is invalid
+     */
+    static validateWorkspaceName(workspace: string): void;
+    /**
+     * Validate workspace is in allowed list (if configured)
+     * @param workspace - Workspace name
+     * @param config - Validation configuration
+     * @throws {ValidationError} If workspace is not allowed
+     */
+    static validateAllowedWorkspace(workspace: string, config?: ValidationConfig): void;
+    /**
+     * Validate required variables are set
+     * Checks for TF_VAR_* environment variables
+     * @param requiredVars - List of required variable names (without TF_VAR_ prefix)
+     * @param env - Environment variables
+     * @throws {ValidationError} If required variables are missing
+     */
+    static validateRequiredVariables(requiredVars: string[], env?: Record<string, string>): void;
+    /**
+     * Validate backend configuration
+     * @param config - Terraflow configuration
+     * @throws {ValidationError} If backend configuration is invalid
+     */
+    static validateBackendConfig(config: TerraflowConfig): Promise<void>;
+    /**
+     * Validate cloud credentials are available (placeholder for future implementation)
+     * @param backendType - Backend type
+     * @param cloud - Cloud information
+     * @throws {ValidationError} If credentials are missing
+     */
+    static validateCloudCredentials(backendType: string, cloud: ExecutionContext['cloud']): Promise<void>;
+    /**
+     * Validate plugin configurations (placeholder for future implementation)
+     * @param _config - Terraflow configuration
+     * @throws {ValidationError} If plugin configuration is invalid
+     */
+    static validatePluginConfigs(_config: TerraflowConfig): Promise<void>;
+    /**
+     * Run validations based on command type
+     * @param command - Terraform command
+     * @param config - Terraflow configuration
+     * @param context - Execution context
+     * @param options - Validation options
+     * @returns Validation result
+     */
+    static validate(command: string, config: TerraflowConfig, context: ExecutionContext, options?: {
+        skipCommitCheck?: boolean;
+        dryRun?: boolean;
+    }): Promise<ValidationResult>;
+    /**
+     * Run full validations for apply, destroy, import, refresh commands
+     */
+    private static runFullValidations;
+    /**
+     * Run backend validations for plan, state, workspace, output, show commands
+     */
+    private static runBackendValidations;
+}
+//# sourceMappingURL=validator.d.ts.map

package/dist/core/validator.js

@@ -0,0 +1,304 @@
+"use strict";
+/**
+ * Validation engine
+ * Validates configuration, workspace, and environment
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Validator = exports.MINIMAL_VALIDATION_COMMANDS = exports.BACKEND_REQUIRED_COMMANDS = exports.FULL_VALIDATION_COMMANDS = void 0;
+const child_process_1 = require("child_process");
+const git_1 = require("../utils/git");
+const errors_1 = require("./errors");
+const logger_1 = require("../utils/logger");
+/**
+ * Command categories for validation
+ */
+exports.FULL_VALIDATION_COMMANDS = ['apply', 'destroy', 'import', 'refresh'];
+exports.BACKEND_REQUIRED_COMMANDS = ['plan', 'state', 'workspace', 'output', 'show'];
+exports.MINIMAL_VALIDATION_COMMANDS = ['fmt', 'validate', 'version', 'providers'];
+/**
+ * Validation engine for Terraflow
+ */
+class Validator {
+    /**
+     * Validate terraform is installed and accessible
+     * @throws {ValidationError} If terraform is not installed
+     */
+    static async validateTerraformInstalled() {
+        try {
+            (0, child_process_1.execSync)('terraform version', {
+                stdio: ['pipe', 'pipe', 'pipe'],
+                encoding: 'utf8',
+            });
+        }
+        catch {
+            throw new errors_1.ValidationError('Terraform is not installed or not available in PATH. Please install Terraform and ensure it is in your PATH.');
+        }
+    }
+    /**
+     * Check if git is available (not fatal if missing)
+     * @returns True if git is available
+     */
+    static async validateGitRepo(cwd = process.cwd()) {
+        return git_1.GitUtils.isGitRepository(cwd);
+    }
+    /**
+     * Validate git working directory is clean (no uncommitted changes)
+     * @param cwd - Current working directory
+     * @throws {ValidationError} If working directory is not clean
+     */
+    static async validateGitCommit(cwd = process.cwd()) {
+        const isClean = await git_1.GitUtils.isClean(cwd);
+        if (!isClean) {
+            throw new errors_1.ValidationError('Git working directory has uncommitted changes. Please commit or stash your changes before running this command. Use --skip-commit-check to bypass this validation.');
+        }
+    }
+    /**
+     * Validate workspace name matches terraform naming rules
+     * Must match: /^[a-zA-Z0-9_-]+$/
+     * @param workspace - Workspace name to validate
+     * @throws {ValidationError} If workspace name is invalid
+     */
+    static validateWorkspaceName(workspace) {
+        if (!/^[a-zA-Z0-9_-]+$/.test(workspace)) {
+            throw new errors_1.ValidationError(`Invalid workspace name "${workspace}". Workspace names must match /^[a-zA-Z0-9_-]+$/ (alphanumeric, underscore, hyphen only).`);
+        }
+    }
+    /**
+     * Validate workspace is in allowed list (if configured)
+     * @param workspace - Workspace name
+     * @param config - Validation configuration
+     * @throws {ValidationError} If workspace is not allowed
+     */
+    static validateAllowedWorkspace(workspace, config) {
+        if (!config || !config.allowed_workspaces || config.allowed_workspaces.length === 0) {
+            // No restrictions
+            return;
+        }
+        if (!config.allowed_workspaces.includes(workspace)) {
+            throw new errors_1.ValidationError(`Workspace "${workspace}" is not in the allowed list. Allowed workspaces: ${config.allowed_workspaces.join(', ')}`);
+        }
+    }
+    /**
+     * Validate required variables are set
+     * Checks for TF_VAR_* environment variables
+     * @param requiredVars - List of required variable names (without TF_VAR_ prefix)
+     * @param env - Environment variables
+     * @throws {ValidationError} If required variables are missing
+     */
+    static validateRequiredVariables(requiredVars, env = process.env) {
+        if (!requiredVars || requiredVars.length === 0) {
+            return;
+        }
+        const missing = [];
+        for (const varName of requiredVars) {
+            const envVarName = `TF_VAR_${varName}`;
+            if (!env[envVarName]) {
+                missing.push(varName);
+            }
+        }
+        if (missing.length > 0) {
+            throw new errors_1.ValidationError(`Required Terraform variables are missing: ${missing.join(', ')}. Set them as environment variables: ${missing.map((v) => `TF_VAR_${v}`).join(', ')}`);
+        }
+    }
+    /**
+     * Validate backend configuration
+     * @param config - Terraflow configuration
+     * @throws {ValidationError} If backend configuration is invalid
+     */
+    static async validateBackendConfig(config) {
+        if (!config.backend) {
+            return; // Local backend, no validation needed
+        }
+        // For now, basic validation - plugins will do detailed validation
+        if (!config.backend.type) {
+            throw new errors_1.ValidationError('Backend type is required');
+        }
+        // TODO: Plugin-specific validation will be handled by backend plugins
+    }
+    /**
+     * Validate cloud credentials are available (placeholder for future implementation)
+     * @param backendType - Backend type
+     * @param cloud - Cloud information
+     * @throws {ValidationError} If credentials are missing
+     */
+    static async validateCloudCredentials(backendType, cloud) {
+        if (backendType === 'local') {
+            return; // No credentials needed for local backend
+        }
+        // TODO: Implement credential validation for AWS, Azure, GCP
+        // For now, just check if provider is detected
+        if (backendType === 's3' && cloud.provider !== 'aws') {
+            logger_1.Logger.warn('S3 backend configured but AWS provider not detected');
+        }
+        if (backendType === 'azurerm' && cloud.provider !== 'azure') {
+            logger_1.Logger.warn('Azure backend configured but Azure provider not detected');
+        }
+        if (backendType === 'gcs' && cloud.provider !== 'gcp') {
+            logger_1.Logger.warn('GCS backend configured but GCP provider not detected');
+        }
+    }
+    /**
+     * Validate plugin configurations (placeholder for future implementation)
+     * @param _config - Terraflow configuration
+     * @throws {ValidationError} If plugin configuration is invalid
+     */
+    static async validatePluginConfigs(_config) {
+        // TODO: Plugin validation will be handled by plugin system
+        // This is a placeholder for future implementation
+    }
+    /**
+     * Run validations based on command type
+     * @param command - Terraform command
+     * @param config - Terraflow configuration
+     * @param context - Execution context
+     * @param options - Validation options
+     * @returns Validation result
+     */
+    static async validate(command, config, context, options = {}) {
+        const errors = [];
+        const warnings = [];
+        try {
+            // Always validate terraform installation
+            await Validator.validateTerraformInstalled();
+        }
+        catch (error) {
+            const message = error instanceof errors_1.ValidationError ? error.message : String(error);
+            errors.push(message);
+            if (!options.dryRun) {
+                throw error;
+            }
+        }
+        try {
+            // Always validate workspace name format
+            Validator.validateWorkspaceName(context.workspace);
+        }
+        catch (error) {
+            const message = error instanceof errors_1.ValidationError ? error.message : String(error);
+            errors.push(message);
+            if (!options.dryRun) {
+                throw error;
+            }
+        }
+        // Check git availability (not fatal)
+        const gitAvailable = await Validator.validateGitRepo(context.workingDir);
+        if (!gitAvailable) {
+            warnings.push('Git repository not detected. Some features may not work correctly.');
+        }
+        // Command-specific validations
+        if (exports.FULL_VALIDATION_COMMANDS.includes(command)) {
+            await Validator.runFullValidations(config, context, options, errors, warnings);
+        }
+        else if (exports.BACKEND_REQUIRED_COMMANDS.includes(command)) {
+            await Validator.runBackendValidations(config, context, errors, warnings);
+        }
+        // MINIMAL_VALIDATION_COMMANDS only need terraform installed (already validated)
+        // In dry-run mode, return errors without throwing
+        if (options.dryRun && errors.length > 0) {
+            return {
+                passed: false,
+                errors,
+                warnings,
+            };
+        }
+        // In normal mode, throw if there are errors
+        if (errors.length > 0) {
+            throw new errors_1.ValidationError(`Validation failed:\n${errors.map((e) => `  - ${e}`).join('\n')}`);
+        }
+        return {
+            passed: true,
+            errors: [],
+            warnings,
+        };
+    }
+    /**
+     * Run full validations for apply, destroy, import, refresh commands
+     */
+    static async runFullValidations(config, context, options, errors, _warnings) {
+        // Git working directory clean
+        if (!options.skipCommitCheck && !config['skip-commit-check']) {
+            try {
+                await Validator.validateGitCommit(context.workingDir);
+            }
+            catch (error) {
+                const message = error instanceof errors_1.ValidationError ? error.message : String(error);
+                errors.push(message);
+                if (!options.dryRun) {
+                    throw error;
+                }
+            }
+        }
+        // Workspace in allowed list
+        try {
+            Validator.validateAllowedWorkspace(context.workspace, config.validations);
+        }
+        catch (error) {
+            const message = error instanceof errors_1.ValidationError ? error.message : String(error);
+            errors.push(message);
+            if (!options.dryRun) {
+                throw error;
+            }
+        }
+        // Backend config valid
+        try {
+            await Validator.validateBackendConfig(config);
+        }
+        catch (error) {
+            const message = error instanceof errors_1.ValidationError ? error.message : String(error);
+            errors.push(message);
+            if (!options.dryRun) {
+                throw error;
+            }
+        }
+        // Cloud credentials available
+        if (config.backend && config.backend.type !== 'local') {
+            try {
+                await Validator.validateCloudCredentials(config.backend.type, context.cloud);
+            }
+            catch (error) {
+                const message = error instanceof errors_1.ValidationError ? error.message : String(error);
+                errors.push(message);
+                if (!options.dryRun) {
+                    throw error;
+                }
+            }
+        }
+        // Plugin configs valid
+        try {
+            await Validator.validatePluginConfigs(config);
+        }
+        catch (error) {
+            const message = error instanceof errors_1.ValidationError ? error.message : String(error);
+            errors.push(message);
+            if (!options.dryRun) {
+                throw error;
+            }
+        }
+    }
+    /**
+     * Run backend validations for plan, state, workspace, output, show commands
+     */
+    static async runBackendValidations(config, context, errors, _warnings) {
+        // Backend config valid (if not local)
+        if (config.backend && config.backend.type !== 'local') {
+            try {
+                await Validator.validateBackendConfig(config);
+            }
+            catch (error) {
+                const message = error instanceof errors_1.ValidationError ? error.message : String(error);
+                errors.push(message);
+                throw error;
+            }
+            // Cloud credentials available
+            try {
+                await Validator.validateCloudCredentials(config.backend.type, context.cloud);
+            }
+            catch (error) {
+                const message = error instanceof errors_1.ValidationError ? error.message : String(error);
+                errors.push(message);
+                throw error;
+            }
+        }
+    }
+}
+exports.Validator = Validator;
+//# sourceMappingURL=validator.js.map

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+/**
+ * Terraflow CLI - Main entry point
+ * An opinionated Terraform workflow CLI with multi-cloud support
+ */
+export {};
+//# sourceMappingURL=index.d.ts.map