grada-run 0.0.2 → 0.32.0

package/src/commands/apply.js

@@ -0,0 +1,214 @@
+import path from 'path';
+import fs from 'fs';
+import { intro, outro, spinner, log, cancel, confirm, isCancel } from '@clack/prompts';
+import color from 'picocolors';
+import { renderDryRunPreview, parseTerraformConfig, buildCostTelemetryProps } from '../utils/visualizer.js';
+import { detectFramework } from '../utils/detector.js';
+import { trackEvent, flushTelemetry, trackSuccess, trackFailure } from '../core/telemetry.js';
+import { failCommand } from '../utils/command.js';
+import { normalizeOptions } from '../utils/args.js';
+import { spawnSync } from 'child_process';
+import { provisionStateBucket } from '../utils/aws.js';
+import { runTerraformCommand, getTerraformOutputs } from '../utils/terraform.js';
+import { readSleepState, resolveSleepTarget } from '../utils/sleep-state.js';
+import { resolveProjectName } from '../utils/resolvers.js';
+import { ensureLambdaSeedImage } from '../utils/lambda-ecr.js';
+
+export async function applyStack(input = {}) {
+    const options = normalizeOptions(input);
+    intro(color.bgCyan(color.black(' grada apply ☁️  ')));
+
+    const targetDir = process.cwd();
+    const tfDir = path.join(targetDir, 'terraform');
+
+    // 1. Verify that the user is inside a project generated by grada
+    if (!fs.existsSync(tfDir) || !fs.existsSync(path.join(tfDir, 'main.tf'))) {
+        return failCommand({
+            print: () => {
+                log.error(color.red('✖ No terraform directory found in current path.'));
+                log.message('Please run "npx grada-run" first to generate your infrastructure templates.');
+            },
+        });
+    }
+
+    // 1b. Warn when this environment is asleep: apply resets the app
+    // desired count while the database stays stopped, so fresh tasks would
+    // crash-loop. Advisory only — the apply still proceeds.
+    const sleepState = readSleepState(targetDir);
+    const sleepTarget = resolveSleepTarget({}, targetDir);
+    if (sleepState[sleepTarget.envKey]) {
+        log.warn(color.yellow(`⚠ Environment "${sleepTarget.envKey}" is asleep. Run ${color.green('npx grada-run wake')} first, or this apply will start tasks against a stopped database.`));
+    }
+
+    // 2. Read the actual AWS configuration from disk (CPU, Memory, Region, Database)
+    const detectedConfig = parseTerraformConfig(tfDir);
+    detectedConfig.projectName = path.basename(process.cwd());
+    const costProps = buildCostTelemetryProps(detectedConfig);
+
+    // 3. Detect the framework name using your existing detector
+    const detectedFw = detectFramework(targetDir);
+    detectedConfig.framework = detectedFw ? detectedFw.name : 'Container';
+
+    // 4. Run the visualizer (passing the flag so it knows whether to prompt)
+    if (options.isDryRun) {
+        await renderDryRunPreview(detectedConfig, true);
+        outro(color.green('Dry run complete. No infrastructure was provisioned.'));
+        await trackSuccess('infrastructure_dry_run', {
+            framework: detectedConfig.framework,
+            ...costProps,
+        });
+        process.exit(0);
+    } else if (options.autoApprove) {
+        await renderDryRunPreview(detectedConfig, true);
+    } else if (!options.autoApprove) {
+        const confirmed = await renderDryRunPreview(detectedConfig, false);
+        if (!confirmed) {
+            cancel('Apply aborted.');
+            process.exit(0);
+        }
+    }
+
+    const s = spinner();
+    const runTerraform = options.runTerraformImpl || runTerraformCommand;
+    const runSync = options.spawnSyncImpl || spawnSync;
+
+    try {
+        // 5. Run terraform init
+        s.start('Initializing Terraform plugins...');
+        await runTerraform(['init', '-upgrade'], tfDir, s, 'Initializing');
+        s.stop('Terraform initialized.');
+
+        // 5b. Lambda Day-0 bootstrap: CreateFunction rejects an empty ECR
+        // repository, so ensure the repository exists and seed a minimal
+        // placeholder image when :latest hasn't been pushed yet. No-op on
+        // reruns once CI owns the tag.
+        if (detectedConfig.computeTarget === 'lambda') {
+            s.start('Ensuring ECR repository for the Lambda image...');
+            await runTerraform(['apply', '-target=aws_ecr_repository.app', '-input=false', '-auto-approve'], tfDir, s, 'Ensuring ECR repository');
+            s.stop('ECR repository ready.');
+
+            s.start('Checking for a deployable container image...');
+            const seed = ensureLambdaSeedImage({
+                run: runSync,
+                repository: `${resolveProjectName({}, targetDir)}-repo`,
+                region: detectedConfig.region,
+            });
+            if (!seed.ok) {
+                if (seed.reason === 'cli-missing') {
+                    throw new Error('AWS CLI is required to bootstrap the Lambda container image on Day 0 (install it from https://aws.amazon.com/cli/, then re-run apply).');
+                }
+                throw new Error(`Could not bootstrap the Day-0 Lambda container image (${seed.reason}${seed.detail ? `: ${seed.detail}` : ''}). Push any image to ECR and re-run apply.`);
+            }
+            s.stop(seed.seeded ? 'Day-0 placeholder image seeded.' : 'Container image already present.');
+        }
+
+        // 6. Run terraform apply
+        s.start('Provisioning AWS infrastructure (this may take 3–5 minutes)...');
+        await runTerraform(['apply', '-auto-approve'], tfDir, s, 'Provisioning');
+        s.stop('Cloud resources provisioned.');
+
+        // 7. Extract and print the outputs
+        const outputs = await getTerraformOutputs(tfDir);
+
+        const cfUrl = outputs.cloudfront_url?.value;
+        const albUrl = outputs.alb_direct_url?.value;
+        const apiUrl = outputs.api_gateway_url?.value;
+
+        let finalMessage = color.green('✅ Infrastructure is live!');
+        if (cfUrl) finalMessage += `\n  🌍 App URL: ${color.cyan(cfUrl)} ${color.dim('(global CDN — share this link)')}`;
+        if (albUrl) finalMessage += `\n  🚦 Direct URL: ${color.gray(albUrl)} ${color.dim('(bypasses the CDN — for debugging)')}`;
+        if (apiUrl) finalMessage += `\n  🔌 API URL: ${color.gray(apiUrl)} ${color.dim('(bypasses the CDN — for debugging)')}`;
+
+        outro(`${finalMessage}\n\n  ${color.yellow('Push code to deploy your app and clear the 503 error:')}\n  ${color.cyan('git add . && git commit -m "ci: infra" && git push origin main')}`);
+
+        const actualProjectName = path.basename(process.cwd());
+        await trackSuccess('infrastructure_applied', {
+            projectName: actualProjectName,
+            framework: detectedConfig.framework,
+            ...costProps
+        });
+
+        process.exit(0);
+
+    } catch (error) {
+        s.stop(color.red('❌ Terraform apply failed.'));
+
+        const errString = error.message || "";
+
+        if (errString.includes('NoSuchBucket') || errString.includes('does not exist')) {
+            log.warn('Terraform state bucket is missing (likely deleted manually or via destroy).');
+
+            trackEvent('recovery_prompted', { type: 'state_bucket_missing' });
+
+            const shouldRecreate = await confirm({
+                message: 'Do you want to automatically recreate the state bucket and resume provisioning?',
+                initialValue: true
+            });
+
+            if (isCancel(shouldRecreate) || !shouldRecreate) {
+                return failCommand({
+                    print: () => cancel('Apply aborted. State bucket remains missing.'),
+                    event: 'recovery_declined',
+                    telemetry: { type: 'state_bucket_missing' },
+                });
+            }
+
+            trackEvent('recovery_accepted', { type: 'state_bucket_missing' });
+
+            try {
+                // 1. Destroy corrupted local cache
+                const dotTerraformPath = path.join(tfDir, '.terraform');
+                if (fs.existsSync(dotTerraformPath)) {
+                    fs.rmSync(dotTerraformPath, { recursive: true, force: true });
+                }
+
+                // 2. Recreate bucket
+                const actualProjectName = path.basename(process.cwd());
+                const targetRegion = detectedConfig.region || process.env.AWS_REGION || 'us-east-2';
+
+                const recSpinner = spinner();
+                recSpinner.start('Recreating S3 state bucket in AWS...');
+                await provisionStateBucket(targetRegion, actualProjectName);
+                recSpinner.stop('✅ State bucket recreated.');
+
+                trackEvent('recovery_successful', { type: 'state_bucket_missing' });
+
+                // 3. Auto-resume the apply flow
+                log.message(color.cyan('Resuming infrastructure provisioning...'));
+                return applyStack({ ...options, autoApprove: true });
+
+            } catch (recoveryErr) {
+                return failCommand({
+                    print: () => {
+                        log.error(color.red('✖ Failed to auto-recover state bucket.'));
+                        log.message(recoveryErr.message || recoveryErr);
+                    },
+                    event: 'recovery_failed',
+                    telemetry: { type: 'state_bucket_missing', error: recoveryErr.message },
+                });
+            }
+        } else if (errString.includes('EntityAlreadyExists') && errString.includes('token.actions.githubusercontent.com')) {
+            log.error(color.red('GitHub OIDC Provider Conflict Detected'));
+            log.message('AWS only allows one GitHub Actions provider per account, and you already have one configured.');
+            log.message('');
+            log.message(`${color.bold('How to fix this:')}`);
+            log.message(`1. Open ${color.cyan('terraform/oidc.tf')}`);
+            log.message(`2. Change ${color.green('create_oidc_provider = true')} to ${color.green('create_oidc_provider = false')}`);
+            log.message(`3. Run ${color.cyan('npx grada-run apply')} again.`);
+        } else {
+            // Generic fallback for unknown errors
+            log.error(color.red(errString));
+            log.message(`${color.bold('To debug manually, navigate to your terraform folder:')}`);
+            log.message(color.cyan('cd terraform && terraform apply'));
+        }
+
+        const actualProjectName = path.basename(process.cwd());
+        await trackFailure('infrastructure_applied', {
+            projectName: actualProjectName,
+            error_code: error.code || 'UNKNOWN',
+            ...costProps
+        });
+
+        return failCommand({ exitCode: 1 });
+    }
+}

package/src/commands/db/backup.js

@@ -0,0 +1,229 @@
+import { RDSClient, CreateDBSnapshotCommand, DescribeDBSnapshotsCommand, CreateDBClusterSnapshotCommand, DescribeDBClusterSnapshotsCommand } from '@aws-sdk/client-rds';
+import color from 'picocolors';
+import { intro, outro, spinner } from '@clack/prompts';
+import { trackSuccess, trackFailure } from '../../core/telemetry.js';
+import { failCommand, failProjectNotInitialized } from '../../utils/command.js';
+import { parseFlags, normalizeOptions, normalizeArgv } from '../../utils/args.js';
+import { handleAuthErrorBranch, resolveClient } from '../../utils/aws.js';
+import { resolveRegion, resolveProjectName, resolveAppName, resolveCwd } from '../../utils/resolvers.js';
+import { findDbTarget, generateSnapshotId, isValidSnapshotId, resolveDbIdentifier, resolveDbClusterIdentifier } from '../../utils/rds.js';
+import { pollUntil, parseTimeoutSeconds } from '../../utils/system.js';
+
+export const DEFAULT_BACKUP_TIMEOUT_SECONDS = 900;
+export const DEFAULT_BACKUP_POLL_INTERVAL_MS = 5000;
+
+const SNAPSHOT_NOT_FOUND_NAMES = new Set(['DBSnapshotNotFound', 'DBSnapshotNotFoundFault']);
+const CLUSTER_SNAPSHOT_NOT_FOUND_NAMES = new Set(['DBClusterSnapshotNotFound', 'DBClusterSnapshotNotFoundFault']);
+
+export function parseDbBackupArgs(argv = []) {
+    const args = normalizeArgv(argv);
+    if (args[0] === 'db') args.shift();
+    if (args[0] === 'backup') args.shift();
+    const { options, rest } = parseFlags(args, {
+        string: [
+            { name: 'id', key: 'snapshotId' },
+            { name: 'timeout', key: 'timeout' },
+            { name: 'project-name', key: 'projectName' },
+            { name: 'region', key: 'region' },
+            { name: 'workspace', key: 'workspace' },
+            { name: 'db-identifier', key: 'dbIdentifier' },
+        ],
+        boolean: ['no-wait', 'headless'],
+    });
+    const positionals = rest.filter((arg) => typeof arg === 'string' && !arg.startsWith('-'));
+    if (positionals.length > 0) options.unexpectedPositionals = positionals;
+    return options;
+}
+
+export async function runDbBackup(input = {}) {
+    const options = normalizeOptions(input);
+    let cwd;
+    let region;
+    let projectName;
+    let dbIdentifier;
+    let dbClusterIdentifier;
+    try {
+        cwd = resolveCwd(options);
+        region = resolveRegion(options, cwd);
+        projectName = resolveProjectName(options, cwd);
+        const appName = resolveAppName(projectName, options.workspace, cwd);
+        dbIdentifier = resolveDbIdentifier({ ...options, projectName }, cwd);
+        dbClusterIdentifier = resolveDbClusterIdentifier({ ...options, projectName }, cwd);
+    } catch {
+        return failProjectNotInitialized({ event: 'db_backup_run' });
+    }
+    const noWait = options.noWait === true || options.noWait === 'true';
+
+    intro(color.bgCyan(color.black(' grada db backup 📸 ')));
+
+    if (Array.isArray(options.unexpectedPositionals) && options.unexpectedPositionals.length > 0) {
+        return failCommand({
+            message: `\n✖ Unexpected argument "${options.unexpectedPositionals[0]}". Set the snapshot id with --id <snapshot-id>.\n`,
+            event: 'db_backup_run',
+            telemetry: { projectName },
+            errorCode: 'UNEXPECTED_POSITIONAL_ARGS',
+            reason: 'unexpected-positional-args',
+            resultExtra: { dbIdentifier, region },
+        });
+    }
+
+    if (options.snapshotId !== undefined && !isValidSnapshotId(options.snapshotId)) {
+        return failCommand({
+            message: `\n✖ Invalid --id "${options.snapshotId}". Snapshot ids start with a letter, use letters/digits/hyphens (no "--", no trailing "-").\n`,
+            event: 'db_backup_run',
+            telemetry: { projectName },
+            errorCode: 'INVALID_SNAPSHOT_ID',
+            reason: 'invalid-snapshot-id',
+            resultExtra: { dbIdentifier, region },
+        });
+    }
+
+    const timeoutSeconds = parseTimeoutSeconds(options.timeout, DEFAULT_BACKUP_TIMEOUT_SECONDS);
+    if (timeoutSeconds === null) {
+        return failCommand({
+            message: `\n✖ Invalid --timeout "${options.timeout}". Use a positive number of seconds (default ${DEFAULT_BACKUP_TIMEOUT_SECONDS}).\n`,
+            event: 'db_backup_run',
+            telemetry: { projectName },
+            errorCode: 'INVALID_TIMEOUT',
+            reason: 'invalid-timeout',
+            resultExtra: { dbIdentifier, region },
+        });
+    }
+
+    const rdsClient = resolveClient(options.rdsClient, RDSClient, { region });
+    const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_BACKUP_POLL_INTERVAL_MS;
+    const timeoutMs = options.timeoutMs ?? timeoutSeconds * 1000;
+
+    const s = spinner();
+    s.start('Finding your database...');
+
+    try {
+        const target = await findDbTarget(rdsClient, { dbIdentifier, dbClusterIdentifier });
+        if (!target) {
+            s.stop();
+            return failCommand({
+                print: () => {
+                    console.log(color.yellow('\n⚠ No database found.'));
+                    console.log(`  No RDS database named ${color.cyan(dbIdentifier)} exists in this environment.`);
+                    console.log(`  Re-run ${color.green('npx grada-run')} and answer "Yes" to the database prompt, then ${color.green('npx grada-run apply')}.\n`);
+                },
+                event: 'db_backup_run',
+                telemetry: { projectName },
+                errorCode: 'RDS_INSTANCE_NOT_FOUND',
+                reason: 'rds-instance-not-found',
+                resultExtra: { dbIdentifier, region },
+            });
+        }
+        const isCluster = target.kind === 'cluster';
+
+        const snapshotId = (typeof options.snapshotId === 'string' && options.snapshotId.trim())
+            ? options.snapshotId.trim()
+            : generateSnapshotId(target.id);
+
+        s.message(`Creating snapshot ${snapshotId}...`);
+        const snapshotTags = [
+            { Key: 'ManagedBy', Value: 'grada' },
+            { Key: 'Project', Value: projectName },
+        ];
+        if (isCluster) {
+            await rdsClient.send(new CreateDBClusterSnapshotCommand({
+                DBClusterIdentifier: target.id,
+                DBClusterSnapshotIdentifier: snapshotId,
+                Tags: snapshotTags,
+            }));
+        } else {
+            await rdsClient.send(new CreateDBSnapshotCommand({
+                DBInstanceIdentifier: target.id,
+                DBSnapshotIdentifier: snapshotId,
+                Tags: snapshotTags,
+            }));
+        }
+
+        if (noWait) {
+            s.stop(color.green('Snapshot creation started.'));
+            console.log(`\n  Snapshot ${color.cyan(snapshotId)} is being created (status: creating).`);
+            console.log(color.dim(`  Restore it later with: npx grada-run db restore ${snapshotId}\n`));
+            await trackSuccess('db_backup_run', { projectName, waited: false, db_kind: target.kind });
+            outro(color.green('Done.'));
+            return { ok: true, snapshotId, status: 'creating' };
+        }
+
+        s.message(`Waiting for snapshot ${snapshotId} to become available...`);
+        const outcome = await pollUntil({
+            intervalMs: pollIntervalMs,
+            timeoutMs,
+            onTick: async ({ elapsedMs }) => {
+                let snapshots = [];
+                try {
+                    if (isCluster) {
+                        const resp = await rdsClient.send(
+                            new DescribeDBClusterSnapshotsCommand({ DBClusterSnapshotIdentifier: snapshotId })
+                        );
+                        snapshots = resp.DBClusterSnapshots || [];
+                    } else {
+                        const resp = await rdsClient.send(
+                            new DescribeDBSnapshotsCommand({ DBSnapshotIdentifier: snapshotId })
+                        );
+                        snapshots = resp.DBSnapshots || [];
+                    }
+                } catch (error) {
+                    // The snapshot is not describable for a moment right after
+                    // creation (eventual consistency), so keep polling.
+                    const notFoundNames = isCluster ? CLUSTER_SNAPSHOT_NOT_FOUND_NAMES : SNAPSHOT_NOT_FOUND_NAMES;
+                    if (error && notFoundNames.has(error.name)) {
+                        s.message(`Waiting for snapshot ${snapshotId}... [${Math.floor(elapsedMs / 1000)}s]`);
+                        return { done: false };
+                    }
+                    throw error;
+                }
+                const snapshot = snapshots[0] || null;
+                if (snapshot && snapshot.Status === 'available') {
+                    return { done: true, value: snapshot };
+                }
+                s.message(`Waiting for snapshot ${snapshotId}... [${Math.floor(elapsedMs / 1000)}s]`);
+                return { done: false };
+            },
+        });
+
+        if (outcome.timedOut) {
+            s.stop(color.yellow('Snapshot still creating.'));
+            return failCommand({
+                print: () => {
+                    console.log(color.yellow(`\n⚠ Snapshot ${snapshotId} did not become available within ${timeoutSeconds}s.`));
+                    console.log('  Creation continues in the background — check status in the AWS console or retry with a larger --timeout.');
+                    console.log(color.dim(`  Restore it once available with: npx grada-run db restore ${snapshotId}\n`));
+                },
+                event: 'db_backup_run',
+                telemetry: { projectName, waited: true },
+                errorCode: 'SNAPSHOT_TIMEOUT',
+                reason: 'snapshot-timeout',
+                resultExtra: { dbIdentifier, region, snapshotId },
+            });
+        }
+
+        s.stop(color.green('Snapshot available.'));
+        console.log(`\n  Snapshot ${color.cyan(snapshotId)} is ready.`);
+        console.log(color.dim(`  Restore it with: npx grada-run db restore ${snapshotId}\n`));
+        await trackSuccess('db_backup_run', { projectName, waited: true, db_kind: target.kind });
+        outro(color.green('Done.'));
+        return { ok: true, snapshotId, status: 'available' };
+    } catch (error) {
+        await trackFailure('db_backup_run', {
+            projectName,
+            error_code: error?.name || 'UNKNOWN',
+            error_message: error?.message,
+        });
+        if (handleAuthErrorBranch(error, s, options)) {
+            return { ok: false, reason: 'error', dbIdentifier, region };
+        }
+        try { s.stop(color.red('❌ Db backup failed.')); } catch { /* spinner already stopped */ }
+        return failCommand({
+            message: `✖ ${error?.message || error}`,
+            hint: 'Check your AWS credentials and region, then try again.',
+            reason: 'error',
+            resultExtra: { dbIdentifier, region },
+        });
+    }
+}
+
+export default runDbBackup;