@friggframework/devtools 2.0.0-next.47 → 2.0.0-next.48

package/frigg-cli/deploy-command/index.js

@@ -0,0 +1,302 @@
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+// Import doctor command for post-deployment health check
+const { doctorCommand } = require('../doctor-command');
+
+// Configuration constants
+const PATHS = {
+    APP_DEFINITION: 'index.js',
+    INFRASTRUCTURE: 'infrastructure.js'
+};
+
+const COMMANDS = {
+    SERVERLESS: 'osls'  // OSS-Serverless (drop-in replacement for serverless v3)
+};
+
+/**
+ * Constructs filtered environment variables for serverless deployment
+ * @param {string[]} appDefinedVariables - Array of environment variable names from app definition
+ * @returns {Object} Filtered environment variables object
+ */
+function buildFilteredEnvironment(appDefinedVariables) {
+    return {
+        // Essential system variables needed to run serverless
+        PATH: process.env.PATH,
+        HOME: process.env.HOME,
+        USER: process.env.USER,
+
+        // AWS credentials and configuration (all AWS_ prefixed variables)
+        ...Object.fromEntries(
+            Object.entries(process.env).filter(([key]) =>
+                key.startsWith('AWS_')
+            )
+        ),
+
+        // App-defined environment variables
+        ...Object.fromEntries(
+            appDefinedVariables
+                .map((key) => [key, process.env[key]])
+                .filter(([_, value]) => value !== undefined)
+        ),
+    };
+}
+
+/**
+ * Loads and parses the app definition from index.js
+ * @returns {Object|null} App definition object or null if not found
+ */
+function loadAppDefinition() {
+    const appDefPath = path.join(process.cwd(), PATHS.APP_DEFINITION);
+
+    if (!fs.existsSync(appDefPath)) {
+        return null;
+    }
+
+    try {
+        const { Definition } = require(appDefPath);
+        return Definition;
+    } catch (error) {
+        console.warn('Could not load appDefinition environment config:', error.message);
+        return null;
+    }
+}
+
+/**
+ * Extracts environment variable names from app definition
+ * @param {Object} appDefinition - App definition object
+ * @returns {string[]} Array of environment variable names
+ */
+function extractEnvironmentVariables(appDefinition) {
+    if (!appDefinition?.environment) {
+        return [];
+    }
+
+    console.log('🔧 Loading environment configuration from appDefinition...');
+
+    const appDefinedVariables = Object.keys(appDefinition.environment).filter(
+        (key) => appDefinition.environment[key] === true
+    );
+
+    console.log(`   Found ${appDefinedVariables.length} environment variables: ${appDefinedVariables.join(', ')}`);
+    return appDefinedVariables;
+}
+
+/**
+ * Handles environment validation warnings
+ * @param {Object} validation - Validation result object
+ * @param {Object} options - Deploy command options
+ */
+function handleValidationWarnings(validation, options) {
+    if (validation.missing.length === 0 || options.skipEnvValidation) {
+        return;
+    }
+
+    console.warn(`⚠️  Warning: Missing ${validation.missing.length} environment variables: ${validation.missing.join(', ')}`);
+    console.warn('   These variables are optional and deployment will continue');
+    console.warn('   Run with --skip-env-validation to bypass this check');
+}
+
+/**
+ * Validates environment variables and builds filtered environment
+ * @param {Object} appDefinition - App definition object
+ * @param {Object} options - Deploy command options
+ * @returns {Object} Filtered environment variables
+ */
+function validateAndBuildEnvironment(appDefinition, options) {
+    if (!appDefinition) {
+        return buildFilteredEnvironment([]);
+    }
+
+    const appDefinedVariables = extractEnvironmentVariables(appDefinition);
+
+    // Try to use the env-validator if available
+    try {
+        const { validateEnvironmentVariables } = require('../../infrastructure/env-validator');
+        const validation = validateEnvironmentVariables(appDefinition);
+
+        handleValidationWarnings(validation, options);
+        return buildFilteredEnvironment(appDefinedVariables);
+
+    } catch (validatorError) {
+        // Validator not available, do basic validation
+        const missingVariables = appDefinedVariables.filter((variable) => !process.env[variable]);
+
+        if (missingVariables.length > 0) {
+            console.warn(`⚠️  Warning: Missing ${missingVariables.length} environment variables: ${missingVariables.join(', ')}`);
+            console.warn('   These variables are optional and deployment will continue');
+            console.warn('   Set them in your CI/CD environment or .env file if needed');
+        }
+
+        return buildFilteredEnvironment(appDefinedVariables);
+    }
+}
+
+/**
+ * Executes the serverless deployment command
+ * @param {Object} environment - Environment variables to pass to serverless
+ * @param {Object} options - Deploy command options
+ * @returns {Promise<number>} Exit code
+ */
+function executeServerlessDeployment(environment, options) {
+    return new Promise((resolve, reject) => {
+        console.log('🚀 Deploying serverless application...');
+
+        const serverlessArgs = [
+            'deploy',
+            '--config',
+            PATHS.INFRASTRUCTURE,
+            '--stage',
+            options.stage,
+        ];
+
+        // Add --force flag if force option is true
+        if (options.force === true) {
+            serverlessArgs.push('--force');
+        }
+
+        const childProcess = spawn(COMMANDS.SERVERLESS, serverlessArgs, {
+            cwd: path.resolve(process.cwd()),
+            stdio: 'inherit',
+            env: {
+                ...environment,
+                SLS_STAGE: options.stage, // Set stage for resource discovery
+            },
+        });
+
+        childProcess.on('error', (error) => {
+            console.error(`Error executing command: ${error.message}`);
+            reject(error);
+        });
+
+        childProcess.on('close', (code) => {
+            if (code !== 0) {
+                console.log(`Child process exited with code ${code}`);
+                resolve(code);
+            } else {
+                resolve(0);
+            }
+        });
+    });
+}
+
+/**
+ * Get stack name from app definition
+ * @param {Object} appDefinition - App definition
+ * @param {Object} options - Deploy options
+ * @returns {string|null} Stack name
+ */
+function getStackName(appDefinition, options) {
+    // Try to get from app definition
+    if (appDefinition?.name) {
+        const stage = options.stage || 'dev';
+        return `${appDefinition.name}-${stage}`;
+    }
+
+    // Try to get from infrastructure.js
+    const infraPath = path.join(process.cwd(), PATHS.INFRASTRUCTURE);
+    if (fs.existsSync(infraPath)) {
+        try {
+            const infraModule = require(infraPath);
+            if (infraModule.service) {
+                const stage = options.stage || 'dev';
+                return `${infraModule.service}-${stage}`;
+            }
+        } catch (error) {
+            // Ignore errors reading infrastructure file
+        }
+    }
+
+    return null;
+}
+
+/**
+ * Run post-deployment health check
+ * @param {string} stackName - CloudFormation stack name
+ * @param {Object} options - Deploy options
+ */
+async function runPostDeploymentHealthCheck(stackName, options) {
+    console.log('\n' + '═'.repeat(80));
+    console.log('Running post-deployment health check...');
+    console.log('═'.repeat(80));
+
+    try {
+        // Run doctor command (will exit process on its own)
+        // Note: We need to catch the exit to prevent deploy from exiting
+        const originalExit = process.exit;
+        let doctorExitCode = 0;
+
+        // Temporarily override process.exit to capture exit code
+        process.exit = (code) => {
+            doctorExitCode = code || 0;
+        };
+
+        try {
+            await doctorCommand(stackName, {
+                region: options.region,
+                format: 'console',
+                verbose: options.verbose,
+            });
+        } catch (error) {
+            console.log(`\n⚠️  Health check encountered an error: ${error.message}`);
+            if (options.verbose) {
+                console.error(error.stack);
+            }
+        } finally {
+            // Restore original process.exit
+            process.exit = originalExit;
+        }
+
+        // Inform user about health check results
+        if (doctorExitCode === 0) {
+            console.log('\n✓ Post-deployment health check: PASSED');
+        } else if (doctorExitCode === 2) {
+            console.log('\n⚠️  Post-deployment health check: DEGRADED');
+            console.log('   Run "frigg repair" to fix detected issues');
+        } else {
+            console.log('\n✗ Post-deployment health check: FAILED');
+            console.log('   Run "frigg doctor" for detailed report');
+            console.log('   Run "frigg repair" to fix detected issues');
+        }
+    } catch (error) {
+        console.log(`\n⚠️  Post-deployment health check failed: ${error.message}`);
+        if (options.verbose) {
+            console.error(error.stack);
+        }
+    }
+}
+
+async function deployCommand(options) {
+    console.log('Deploying the serverless application...');
+
+    const appDefinition = loadAppDefinition();
+    const environment = validateAndBuildEnvironment(appDefinition, options);
+
+    // Execute deployment
+    const exitCode = await executeServerlessDeployment(environment, options);
+
+    // Check if deployment was successful
+    if (exitCode !== 0) {
+        console.error(`\n✗ Deployment failed with exit code ${exitCode}`);
+        process.exit(exitCode);
+    }
+
+    console.log('\n✓ Deployment completed successfully!');
+
+    // Run post-deployment health check (unless --skip-doctor)
+    if (!options.skipDoctor) {
+        const stackName = getStackName(appDefinition, options);
+
+        if (stackName) {
+            await runPostDeploymentHealthCheck(stackName, options);
+        } else {
+            console.log('\n⚠️  Could not determine stack name - skipping health check');
+            console.log('   Run "frigg doctor <stack-name>" manually to check stack health');
+        }
+    } else {
+        console.log('\n⏭️  Skipping post-deployment health check (--skip-doctor)');
+    }
+}
+
+module.exports = { deployCommand };

package/frigg-cli/doctor-command/index.js

@@ -0,0 +1,335 @@
+/**
+ * Frigg Doctor Command
+ *
+ * Performs comprehensive health check on deployed CloudFormation stack
+ * and reports issues like property drift, orphaned resources, and missing resources.
+ *
+ * Usage:
+ *   frigg doctor <stack-name>
+ *   frigg doctor my-app-prod --region us-east-1
+ *   frigg doctor my-app-prod --format json --output report.json
+ *   frigg doctor  # Interactive stack selection
+ */
+
+const path = require('path');
+const fs = require('fs');
+const { select } = require('@inquirer/prompts');
+const { CloudFormationClient, ListStacksCommand } = require('@aws-sdk/client-cloudformation');
+
+// Domain and Application Layer
+const StackIdentifier = require('../../infrastructure/domains/health/domain/value-objects/stack-identifier');
+const RunHealthCheckUseCase = require('../../infrastructure/domains/health/application/use-cases/run-health-check-use-case');
+
+// Infrastructure Layer - AWS Adapters
+const AWSStackRepository = require('../../infrastructure/domains/health/infrastructure/adapters/aws-stack-repository');
+const AWSResourceDetector = require('../../infrastructure/domains/health/infrastructure/adapters/aws-resource-detector');
+
+// Domain Services
+const MismatchAnalyzer = require('../../infrastructure/domains/health/domain/services/mismatch-analyzer');
+const HealthScoreCalculator = require('../../infrastructure/domains/health/domain/services/health-score-calculator');
+
+/**
+ * Format health report for console output
+ * @param {StackHealthReport} report - Health check report
+ * @param {Object} options - Formatting options
+ * @returns {string} Formatted output
+ */
+function formatConsoleOutput(report, options = {}) {
+    const lines = [];
+    const summary = report.getSummary();
+
+    // Header
+    lines.push('');
+    lines.push('═'.repeat(80));
+    lines.push(`  FRIGG DOCTOR - Stack Health Report`);
+    lines.push('═'.repeat(80));
+    lines.push('');
+
+    // Stack Information
+    lines.push(`Stack:        ${summary.stackName}`);
+    lines.push(`Region:       ${summary.region}`);
+    lines.push(`Timestamp:    ${summary.timestamp}`);
+    lines.push('');
+
+    // Health Score
+    const scoreIcon = report.healthScore.isHealthy() ? '✓' : report.healthScore.isUnhealthy() ? '✗' : '⚠';
+    const scoreColor = report.healthScore.isHealthy() ? '' : '';
+    lines.push(`Health Score: ${scoreIcon} ${summary.healthScore}/100 (${summary.qualitativeAssessment})`);
+    lines.push('');
+
+    // Summary Statistics
+    lines.push('─'.repeat(80));
+    lines.push('Resources:');
+    lines.push(`  Total:      ${summary.resourceCount}`);
+    lines.push(`  In Stack:   ${report.getResourcesInStack().length}`);
+    lines.push(`  Drifted:    ${summary.driftedResourceCount}`);
+    lines.push(`  Orphaned:   ${summary.orphanedResourceCount}`);
+    lines.push(`  Missing:    ${summary.missingResourceCount}`);
+    lines.push('');
+
+    lines.push('Issues:');
+    lines.push(`  Total:      ${summary.issueCount}`);
+    lines.push(`  Critical:   ${summary.criticalIssueCount}`);
+    lines.push(`  Warnings:   ${summary.warningCount}`);
+    lines.push('');
+
+    // Issues Detail
+    if (report.issues.length > 0) {
+        lines.push('─'.repeat(80));
+        lines.push('Issue Details:');
+        lines.push('');
+
+        // Group issues by type
+        const criticalIssues = report.getCriticalIssues();
+        const warnings = report.getWarnings();
+
+        if (criticalIssues.length > 0) {
+            lines.push('  CRITICAL ISSUES:');
+            criticalIssues.forEach((issue, idx) => {
+                lines.push(`    ${idx + 1}. [${issue.type}] ${issue.description}`);
+                lines.push(`       Resource: ${issue.resourceType} (${issue.resourceId})`);
+                if (issue.resolution) {
+                    lines.push(`       Fix: ${issue.resolution}`);
+                }
+                lines.push('');
+            });
+        }
+
+        if (warnings.length > 0) {
+            lines.push('  WARNINGS:');
+            warnings.forEach((issue, idx) => {
+                lines.push(`    ${idx + 1}. [${issue.type}] ${issue.description}`);
+                lines.push(`       Resource: ${issue.resourceType} (${issue.resourceId})`);
+                if (issue.resolution) {
+                    lines.push(`       Fix: ${issue.resolution}`);
+                }
+                lines.push('');
+            });
+        }
+    } else {
+        lines.push('─'.repeat(80));
+        lines.push('✓ No issues detected - stack is healthy!');
+        lines.push('');
+    }
+
+    // Recommendations
+    if (report.issues.length > 0) {
+        lines.push('─'.repeat(80));
+        lines.push('Recommended Actions:');
+        lines.push('');
+
+        if (report.getOrphanedResourceCount() > 0) {
+            lines.push(`  • Import ${report.getOrphanedResourceCount()} orphaned resource(s):`);
+            lines.push(`    $ frigg repair --import <stack-name>`);
+            lines.push('');
+        }
+
+        if (report.getDriftedResourceCount() > 0) {
+            lines.push(`  • Reconcile property drift for ${report.getDriftedResourceCount()} resource(s):`);
+            lines.push(`    $ frigg repair --reconcile <stack-name>`);
+            lines.push('');
+        }
+
+        if (report.getMissingResourceCount() > 0) {
+            lines.push(`  • Investigate ${report.getMissingResourceCount()} missing resource(s) and redeploy:`);
+            lines.push(`    $ frigg deploy --stage <stage>`);
+            lines.push('');
+        }
+    }
+
+    lines.push('═'.repeat(80));
+    lines.push('');
+
+    return lines.join('\n');
+}
+
+/**
+ * Format health report as JSON
+ * @param {StackHealthReport} report - Health check report
+ * @returns {string} JSON output
+ */
+function formatJsonOutput(report) {
+    return JSON.stringify(report.toJSON(), null, 2);
+}
+
+/**
+ * Write output to file
+ * @param {string} content - Content to write
+ * @param {string} filePath - Output file path
+ */
+function writeOutputFile(content, filePath) {
+    try {
+        fs.writeFileSync(filePath, content, 'utf8');
+        console.log(`\n✓ Report saved to: ${filePath}`);
+    } catch (error) {
+        console.error(`\n✗ Failed to write output file: ${error.message}`);
+        process.exit(1);
+    }
+}
+
+/**
+ * List CloudFormation stacks in the specified region
+ * @param {string} region - AWS region
+ * @returns {Promise<Array>} Array of stack objects with name and status
+ */
+async function listStacks(region) {
+    const client = new CloudFormationClient({ region });
+
+    try {
+        const command = new ListStacksCommand({
+            StackStatusFilter: [
+                'CREATE_COMPLETE',
+                'UPDATE_COMPLETE',
+                'UPDATE_ROLLBACK_COMPLETE',
+                'ROLLBACK_COMPLETE',
+            ],
+        });
+
+        const response = await client.send(command);
+
+        return (response.StackSummaries || []).map(stack => ({
+            name: stack.StackName,
+            status: stack.StackStatus,
+            createdTime: stack.CreationTime,
+            updatedTime: stack.LastUpdatedTime,
+        }));
+    } catch (error) {
+        throw new Error(`Failed to list CloudFormation stacks: ${error.message}`);
+    }
+}
+
+/**
+ * Prompt user to select a stack from available stacks
+ * @param {string} region - AWS region
+ * @returns {Promise<string>} Selected stack name
+ */
+async function promptForStackSelection(region) {
+    console.log(`\n🔍 Fetching CloudFormation stacks in ${region}...`);
+
+    const stacks = await listStacks(region);
+
+    if (stacks.length === 0) {
+        console.error(`\n✗ No CloudFormation stacks found in ${region}`);
+        console.log('  Make sure you have stacks deployed and the correct AWS credentials configured.');
+        process.exit(1);
+    }
+
+    console.log(`\n✓ Found ${stacks.length} stack(s)\n`);
+
+    // Create choices with stack name and metadata
+    const choices = stacks.map(stack => {
+        const statusIcon = stack.status.includes('COMPLETE') ? '✓' : '⚠';
+        const timeInfo = stack.updatedTime
+            ? `Updated: ${stack.updatedTime.toLocaleDateString()}`
+            : `Created: ${stack.createdTime.toLocaleDateString()}`;
+
+        return {
+            name: `${statusIcon} ${stack.name} (${stack.status}) - ${timeInfo}`,
+            value: stack.name,
+            description: `Status: ${stack.status}`,
+        };
+    });
+
+    const selectedStack = await select({
+        message: 'Select a stack to run health check:',
+        choices,
+        pageSize: 15,
+    });
+
+    return selectedStack;
+}
+
+/**
+ * Execute health check
+ * @param {string} stackName - CloudFormation stack name (optional - will prompt if not provided)
+ * @param {Object} options - Command options
+ */
+async function doctorCommand(stackName, options = {}) {
+    try {
+        // Extract options with defaults
+        const region = options.region || process.env.AWS_REGION || 'us-east-1';
+        const format = options.format || 'console';
+        const verbose = options.verbose || false;
+
+        // If no stack name provided, prompt user to select from available stacks
+        if (!stackName) {
+            stackName = await promptForStackSelection(region);
+        }
+
+        // Show progress to user (always, not just verbose mode)
+        console.log(`\n🏥 Running health check on stack: ${stackName} (${region})\n`);
+
+        // 1. Create stack identifier
+        const stackIdentifier = new StackIdentifier({ stackName, region });
+
+        // 2. Wire up infrastructure layer (AWS adapters)
+        const stackRepository = new AWSStackRepository({ region });
+        const resourceDetector = new AWSResourceDetector({ region });
+
+        // 3. Wire up domain services
+        const mismatchAnalyzer = new MismatchAnalyzer();
+        const healthScoreCalculator = new HealthScoreCalculator();
+
+        // 4. Create and execute use case with progress logging
+        const runHealthCheckUseCase = new RunHealthCheckUseCase({
+            stackRepository,
+            resourceDetector,
+            mismatchAnalyzer,
+            healthScoreCalculator,
+        });
+
+        // Progress callback to show execution status
+        const progressCallback = (step, message) => {
+            if (verbose) {
+                console.log(`   ${message}`);
+            } else {
+                console.log(`${step} ${message}`);
+            }
+        };
+
+        const report = await runHealthCheckUseCase.execute({
+            stackIdentifier,
+            onProgress: progressCallback
+        });
+
+        console.log('✓ Health check complete!\n');
+
+        // 5. Format and output results
+        if (format === 'json') {
+            const jsonOutput = formatJsonOutput(report);
+
+            if (options.output) {
+                writeOutputFile(jsonOutput, options.output);
+            } else {
+                console.log(jsonOutput);
+            }
+        } else {
+            const consoleOutput = formatConsoleOutput(report, options);
+            console.log(consoleOutput);
+
+            if (options.output) {
+                writeOutputFile(consoleOutput, options.output);
+            }
+        }
+
+        // 6. Exit with appropriate code
+        // Exit code 0 = healthy, 1 = unhealthy, 2 = degraded
+        if (report.healthScore.isUnhealthy()) {
+            process.exit(1);
+        } else if (report.healthScore.isDegraded()) {
+            process.exit(2);
+        } else {
+            process.exit(0);
+        }
+    } catch (error) {
+        console.error(`\n✗ Health check failed: ${error.message}`);
+
+        if (options.verbose && error.stack) {
+            console.error(`\nStack trace:\n${error.stack}`);
+        }
+
+        process.exit(1);
+    }
+}
+
+module.exports = { doctorCommand };