@fishawack/lab-env 5.3.0 → 5.4.0-beta.1

package/commands/create/cmds/prune.js

@@ -0,0 +1,723 @@
+const _ = require("../../../globals.js");
+const inquirer = require("inquirer");
+const aws = require("../services/aws/index.js");
+const { setAWSClientDefaults } = require("../services/aws/misc.js");
+const { colorize, Spinner } = require("../libs/utilities");
+const { client, region } = require("../libs/prompts.js");
+
+const VERSIONS_TO_KEEP = 10;
+const STALE_MONTHS = 3;
+const REGIONS = region.choices;
+
+function identifyPrunableVersions(versions) {
+    const sorted = [...versions].sort(
+        (a, b) => new Date(b.DateCreated) - new Date(a.DateCreated),
+    );
+
+    return {
+        keep: sorted.slice(0, VERSIONS_TO_KEEP),
+        prunable: sorted.slice(VERSIONS_TO_KEEP),
+    };
+}
+
+function printVersionReport(results) {
+    let totalVersions = 0;
+    let totalPrunable = 0;
+
+    for (const { appName, keep, prunable } of results) {
+        totalVersions += keep.length + prunable.length;
+        totalPrunable += prunable.length;
+
+        console.log(`\n  ${colorize(appName, "title")}`);
+        console.log(
+            `  Total: ${keep.length + prunable.length} | Keeping: ${keep.length} | Prunable: ${colorize(prunable.length, prunable.length ? "error" : "success")}`,
+        );
+
+        if (keep.length) {
+            console.log(`\n    ${colorize("Keeping", "success")}`);
+            keep.forEach((v) => {
+                const date = new Date(v.DateCreated)
+                    .toISOString()
+                    .split("T")[0];
+                console.log(
+                    `    ${colorize("✓", "success")} ${v.VersionLabel} ${colorize(`(${date})`, "info")}`,
+                );
+            });
+        }
+
+        if (prunable.length) {
+            console.log(`\n    ${colorize("Prunable", "error")}`);
+            prunable.forEach((v) => {
+                const date = new Date(v.DateCreated)
+                    .toISOString()
+                    .split("T")[0];
+                console.log(
+                    `    ${colorize("✕", "error")} ${v.VersionLabel} ${colorize(`(${date})`, "warning")}`,
+                );
+            });
+        } else {
+            console.log(`    ${colorize("(nothing to prune)", "success")}`);
+        }
+    }
+
+    return { totalVersions, totalPrunable };
+}
+
+async function deleteVersions(results) {
+    let deleted = 0;
+    let failed = 0;
+
+    for (const { client, region, appName, prunable } of results) {
+        setAWSClientDefaults(client, region);
+
+        for (const v of prunable) {
+            let attempts = 0;
+
+            while (attempts < 3) {
+                try {
+                    await aws.elasticbeanstalk.deleteApplicationVersion(
+                        appName,
+                        v.VersionLabel,
+                    );
+                    deleted++;
+                    break;
+                } catch (e) {
+                    attempts++;
+
+                    if (
+                        e.name === "TooManyRequestsException" ||
+                        e.name === "Throttling" ||
+                        e.$metadata?.httpStatusCode === 429
+                    ) {
+                        const delay = Math.pow(2, attempts) * 1000;
+                        await new Promise((r) => setTimeout(r, delay));
+                    } else {
+                        failed++;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    return { deleted, failed };
+}
+
+function isProductionDistribution(tags) {
+    const env = tags.find((t) => t.Key === "environment");
+
+    if (!env) return false;
+
+    return /prod/i.test(env.Value);
+}
+
+function isAutomatedDistribution(tags) {
+    return tags.some((t) => t.Key === "automated");
+}
+
+function isStaleDistribution(lastModified) {
+    const cutoff = new Date();
+    cutoff.setMonth(cutoff.getMonth() - STALE_MONTHS);
+
+    return new Date(lastModified) < cutoff;
+}
+
+function getTagValue(tags, key) {
+    const tag = tags.find((t) => t.Key === key);
+    return tag ? tag.Value : null;
+}
+
+function printDistributionReport(results) {
+    let totalDistributions = 0;
+    let totalPrunable = 0;
+
+    for (const { keep, prunable, ignored } of results) {
+        totalDistributions +=
+            keep.length + prunable.length + (ignored?.length || 0);
+        totalPrunable += prunable.length;
+    }
+
+    for (const { keep } of results) {
+        if (!keep.length) continue;
+
+        console.log(`\n    ${colorize("Keeping", "success")}`);
+        keep.forEach((d) => {
+            const date = new Date(d.lastActivity || d.LastModifiedTime)
+                .toISOString()
+                .split("T")[0];
+            const env = d.environment || "unknown";
+            console.log(
+                `    ${colorize("✓", "success")} ${d.Id} ${colorize(d.name, "info")} ${colorize(date, "warning")} ${colorize(env, "success")} ${colorize(`(${d.reason})`, "info")}`,
+            );
+        });
+    }
+
+    for (const { ignored } of results) {
+        if (!ignored?.length) continue;
+
+        console.log(`\n    ${colorize("Ignored (not automated)", "info")}`);
+        ignored.forEach((d) => {
+            const date = new Date(d.LastModifiedTime)
+                .toISOString()
+                .split("T")[0];
+            const env = d.environment || "unknown";
+            console.log(
+                `    ${colorize("-", "info")} ${d.Id} ${colorize(d.name, "info")} ${colorize(date, "warning")} ${colorize(env, "success")}`,
+            );
+        });
+    }
+
+    for (const { prunable } of results) {
+        if (!prunable.length) continue;
+
+        console.log(`\n    ${colorize("Prunable", "error")}`);
+        prunable.forEach((d) => {
+            const date = new Date(d.lastActivity || d.LastModifiedTime)
+                .toISOString()
+                .split("T")[0];
+            const env = d.environment || "unknown";
+            console.log(
+                `    ${colorize("✕", "error")} ${d.Id} ${colorize(d.name, "info")} ${colorize(date, "warning")} ${colorize(env, "success")}`,
+            );
+        });
+    }
+
+    return { totalDistributions, totalPrunable };
+}
+
+async function deleteDistributions(results) {
+    let deleted = 0;
+    let failed = 0;
+
+    for (const { client, region, prunable } of results) {
+        setAWSClientDefaults(client, region);
+
+        for (const d of prunable) {
+            try {
+                await aws.staticTerminate(
+                    d.name,
+                    d.repository,
+                    d.environment,
+                    d.Id,
+                );
+                deleted++;
+            } catch {
+                failed++;
+            }
+        }
+    }
+
+    return { deleted, failed };
+}
+
+async function resolveClients(argv) {
+    if (argv.all) return client.choices;
+    if (argv.client) return [argv.client];
+
+    const { check } = await inquirer.prompt([
+        {
+            type: "confirm",
+            name: "check",
+            message: "Prune all clients?",
+            default: true,
+        },
+    ]);
+
+    if (check) return client.choices;
+
+    const answers = await inquirer.prompt([client]);
+    return [answers.client];
+}
+
+async function resolveRegions(argv) {
+    if (argv.all) return REGIONS;
+    if (argv.region) return [argv.region];
+
+    const { check } = await inquirer.prompt([
+        {
+            type: "confirm",
+            name: "check",
+            message: "Prune for all regions?",
+            default: true,
+        },
+    ]);
+
+    if (check) return REGIONS;
+
+    const answers = await inquirer.prompt([region]);
+    return [answers.region];
+}
+
+async function resolveApplications(argv, applications) {
+    if (argv.all) return applications;
+
+    if (argv.application) {
+        const filtered = applications.filter(
+            (app) => app.ApplicationName === argv.application,
+        );
+
+        if (!filtered.length) {
+            console.log(
+                `\n  ${colorize(`Application "${argv.application}" not found.`, "error")}\n`,
+            );
+        }
+
+        return filtered;
+    }
+
+    const { check } = await inquirer.prompt([
+        {
+            type: "confirm",
+            name: "check",
+            message: "Prune all applications?",
+            default: true,
+        },
+    ]);
+
+    if (check) return applications;
+
+    const { selected } = await inquirer.prompt([
+        {
+            type: "checkbox",
+            name: "selected",
+            message: "Which applications would you like to prune?",
+            choices: applications.map((app) => ({
+                name: app.ApplicationName,
+                value: app.ApplicationName,
+            })),
+            validate: (input) =>
+                input.length > 0 || "Select at least one application",
+        },
+    ]);
+
+    return applications.filter((app) => selected.includes(app.ApplicationName));
+}
+
+module.exports = [
+    "prune",
+    _.config.preset === "devops" ? "Prune unused resources from AWS" : false,
+    (yargs) => {
+        yargs.option("all", {
+            alias: "a",
+            describe: "Prune all clients, regions and applications",
+            type: "boolean",
+            default: false,
+        });
+        yargs.option("client", {
+            alias: "c",
+            describe: "AWS account to use",
+            type: "string",
+        });
+        yargs.option("region", {
+            alias: "r",
+            describe: "AWS region to use",
+            type: "string",
+        });
+        yargs.option("application", {
+            describe: "Application name to prune",
+            type: "string",
+        });
+        yargs.option("include-ignored", {
+            alias: "i",
+            describe: "Include non-automated distributions in prune targets",
+            type: "boolean",
+            default: false,
+        });
+    },
+    async (argv) => {
+        const { resource } = await inquirer.prompt([
+            {
+                type: "list",
+                name: "resource",
+                message: "What would you like to prune?",
+                choices: [
+                    "Elastic Beanstalk application versions",
+                    "CloudFront static distributions",
+                ],
+            },
+        ]);
+
+        const clients = await resolveClients(argv);
+        const regions =
+            resource === "CloudFront static distributions"
+                ? ["us-east-1"]
+                : await resolveRegions(argv);
+
+        if (resource === "Elastic Beanstalk application versions") {
+            const allResults = [];
+
+            for (const c of clients) {
+                for (const r of regions) {
+                    setAWSClientDefaults(c, r);
+
+                    let applications;
+
+                    try {
+                        applications =
+                            await aws.elasticbeanstalk.listApplications();
+                    } catch {
+                        continue;
+                    }
+
+                    if (!applications.length) continue;
+
+                    const selected = await resolveApplications(
+                        argv,
+                        applications,
+                    );
+
+                    if (!selected.length) continue;
+
+                    console.log(`\n  ${colorize(`${c} / ${r}`, "divider")}`);
+
+                    for (const app of selected) {
+                        const versions =
+                            await aws.elasticbeanstalk.listApplicationVersions(
+                                app.ApplicationName,
+                            );
+                        const { keep, prunable } =
+                            identifyPrunableVersions(versions);
+                        allResults.push({
+                            client: c,
+                            region: r,
+                            appName: app.ApplicationName,
+                            keep,
+                            prunable,
+                        });
+                    }
+
+                    printVersionReport(allResults.slice(-selected.length));
+                }
+            }
+
+            const totalPrunable = allResults.reduce(
+                (sum, r) => sum + r.prunable.length,
+                0,
+            );
+            const totalVersions = allResults.reduce(
+                (sum, r) => sum + r.keep.length + r.prunable.length,
+                0,
+            );
+
+            console.log(
+                `\n  ${colorize("Grand total", "title")}: ${totalVersions} versions, keeping ${VERSIONS_TO_KEEP} per app, ${colorize(`${totalPrunable} prunable`, totalPrunable ? "error" : "success")}\n`,
+            );
+
+            if (!totalPrunable) return;
+
+            const { confirm } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "confirm",
+                    message: `Delete ${colorize(totalPrunable, "error")} application version(s)? This cannot be undone.`,
+                    default: false,
+                },
+            ]);
+
+            if (!confirm) {
+                console.log(`\n  ${colorize("Aborted.", "warning")}\n`);
+                return;
+            }
+
+            const { deleted, failed } = await Spinner.prototype.simple(
+                `Deleting ${totalPrunable} application version(s)`,
+                () => deleteVersions(allResults),
+            );
+
+            console.log(
+                `\n  ${colorize("✓", "success")} Deleted ${colorize(deleted, "success")} application version(s)${failed ? ` (${colorize(`${failed} failed`, "error")})` : ""}\n`,
+            );
+        }
+
+        if (resource === "CloudFront static distributions") {
+            const allResults = [];
+
+            for (const c of clients) {
+                setAWSClientDefaults(c, "us-east-1");
+
+                const spinner = new Spinner(`Scanning ${c}`, true);
+
+                let distributions;
+
+                try {
+                    distributions = await aws.cloudfront.listDistributions();
+                } catch {
+                    spinner.ora.stop();
+                    continue;
+                }
+
+                if (!distributions.length) {
+                    spinner.ora.stop();
+                    continue;
+                }
+
+                const keep = [];
+                const prunable = [];
+                const ignored = [];
+
+                for (const dist of distributions) {
+                    let tags;
+                    let attempts = 0;
+
+                    while (attempts < 5) {
+                        try {
+                            // prettier-ignore
+                            tags = await aws.cloudfront.getDistributionTags(dist.ARN);
+                            break;
+                        } catch (e) {
+                            attempts++;
+
+                            if (
+                                e.name === "Throttling" ||
+                                e.$metadata?.httpStatusCode === 429
+                            ) {
+                                const delay = Math.pow(2, attempts) * 1000;
+                                await new Promise((r) => setTimeout(r, delay));
+                            } else {
+                                break;
+                            }
+                        }
+                    }
+
+                    if (!tags) continue;
+
+                    // Throttle to stay under ListTagsForResource rate limit
+                    await new Promise((r) => setTimeout(r, 200));
+
+                    if (!isAutomatedDistribution(tags)) {
+                        const origin =
+                            dist.Origins?.Items?.[0]?.DomainName || "";
+                        const name = origin.split(".s3.")[0];
+                        const environment = getTagValue(tags, "environment");
+                        const repository = getTagValue(tags, "repository");
+                        ignored.push({
+                            client: c,
+                            region: "us-east-1",
+                            Id: dist.Id,
+                            name,
+                            LastModifiedTime: dist.LastModifiedTime,
+                            environment,
+                            repository,
+                        });
+                        continue;
+                    }
+
+                    const repository = getTagValue(tags, "repository");
+                    const environment = getTagValue(tags, "environment");
+                    const origin = dist.Origins?.Items?.[0]?.DomainName || "";
+                    const name = origin.split(".s3.")[0];
+
+                    const entry = {
+                        client: c,
+                        region: "us-east-1",
+                        Id: dist.Id,
+                        name,
+                        LastModifiedTime: dist.LastModifiedTime,
+                        lastActivity: dist.LastModifiedTime,
+                        repository,
+                        environment,
+                    };
+
+                    // Use latest invalidation date as activity indicator
+                    try {
+                        // prettier-ignore
+                        const invalidationDate = await aws.cloudfront.getLatestInvalidationDate(dist.Id);
+                        if (invalidationDate) {
+                            const invDate = new Date(invalidationDate);
+                            const modDate = new Date(dist.LastModifiedTime);
+                            if (invDate > modDate) {
+                                entry.lastActivity = invalidationDate;
+                            }
+                        }
+                    } catch {
+                        // Fall back to LastModifiedTime
+                    }
+
+                    // Throttle API calls
+                    await new Promise((r) => setTimeout(r, 200));
+
+                    if (isProductionDistribution(tags)) {
+                        keep.push({
+                            ...entry,
+                            reason: "production",
+                        });
+                    } else if (!isStaleDistribution(entry.lastActivity)) {
+                        keep.push({
+                            ...entry,
+                            reason: "recent",
+                        });
+                    } else {
+                        prunable.push(entry);
+                    }
+                }
+
+                spinner.ora.stop();
+
+                if (!keep.length && !prunable.length && !ignored.length)
+                    continue;
+
+                const total = keep.length + prunable.length + ignored.length;
+
+                console.log(`\n  ${colorize(c, "divider")}`);
+                console.log(
+                    `  Total: ${total} | Keeping: ${keep.length} | Ignored: ${ignored.length} | Prunable: ${colorize(prunable.length, prunable.length ? "error" : "success")}`,
+                );
+
+                allResults.push({
+                    client: c,
+                    region: "us-east-1",
+                    keep,
+                    prunable,
+                    ignored,
+                });
+
+                printDistributionReport(allResults.slice(-1));
+            }
+
+            const totalPrunable = allResults.reduce(
+                (sum, r) => sum + r.prunable.length,
+                0,
+            );
+            const totalIgnored = allResults.reduce(
+                (sum, r) => sum + (r.ignored?.length || 0),
+                0,
+            );
+            const totalDistributions = allResults.reduce(
+                (sum, r) =>
+                    sum +
+                    r.keep.length +
+                    r.prunable.length +
+                    (r.ignored?.length || 0),
+                0,
+            );
+
+            console.log(
+                `\n  ${colorize("Grand total", "title")}: ${totalDistributions} distributions, ${totalIgnored} ignored, ${colorize(`${totalPrunable} prunable`, totalPrunable ? "error" : "success")}${argv.includeIgnored ? ` ${colorize(`(+${totalIgnored} ignored included)`, "warning")}` : ""}\n`,
+            );
+
+            const totalTargets = argv.includeIgnored
+                ? totalPrunable + totalIgnored
+                : totalPrunable;
+
+            if (!totalTargets) return;
+
+            const targetLabel = argv.includeIgnored
+                ? `${totalPrunable} prunable + ${totalIgnored} ignored`
+                : `${totalPrunable}`;
+
+            const { confirm } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "confirm",
+                    message: `Delete ${colorize(targetLabel, "error")} distribution(s)? This will remove S3 buckets, CloudFront distributions and functions. This cannot be undone.`,
+                    default: false,
+                },
+            ]);
+
+            if (!confirm) {
+                console.log(`\n  ${colorize("Aborted.", "warning")}\n`);
+                return;
+            }
+
+            const { pruneAll } = await inquirer.prompt([
+                {
+                    type: "confirm",
+                    name: "pruneAll",
+                    message: "Prune all?",
+                    default: false,
+                },
+            ]);
+
+            let toPrune = allResults;
+
+            if (!pruneAll) {
+                const allPrunable = allResults.flatMap((r) =>
+                    r.prunable.map((d) => ({
+                        ...d,
+                        _source: "prunable",
+                    })),
+                );
+
+                const allIgnored = argv.includeIgnored
+                    ? allResults.flatMap((r) =>
+                          (r.ignored || []).map((d) => ({
+                              ...d,
+                              _source: "ignored",
+                          })),
+                      )
+                    : [];
+
+                const formatChoice = (d, label) => {
+                    const date = new Date(d.lastActivity || d.LastModifiedTime)
+                        .toISOString()
+                        .split("T")[0];
+                    const env = d.environment || "unknown";
+                    const suffix = label ? ` [${label}]` : "";
+                    return {
+                        name: `${d.Id} ${d.name} ${date} ${env}${suffix}`,
+                        value: d.Id,
+                    };
+                };
+
+                const choices = [];
+
+                if (allPrunable.length) {
+                    choices.push(new inquirer.Separator("── Prunable ──"));
+                    choices.push(...allPrunable.map((d) => formatChoice(d)));
+                }
+
+                if (allIgnored.length) {
+                    // prettier-ignore
+                    choices.push(new inquirer.Separator("── Ignored (not automated) ──"));
+                    choices.push(
+                        ...allIgnored.map((d) => formatChoice(d, "ignored")),
+                    );
+                }
+
+                const { selected } = await inquirer.prompt([
+                    {
+                        type: "checkbox",
+                        name: "selected",
+                        message: "Which distributions would you like to prune?",
+                        choices,
+                        validate: (input) =>
+                            input.length > 0 ||
+                            "Select at least one distribution",
+                    },
+                ]);
+
+                const selectedSet = new Set(selected);
+
+                toPrune = allResults
+                    .map((r) => ({
+                        ...r,
+                        prunable: [
+                            ...r.prunable,
+                            ...(argv.includeIgnored ? r.ignored || [] : []),
+                        ].filter((d) => selectedSet.has(d.Id)),
+                    }))
+                    .filter((r) => r.prunable.length > 0);
+            } else if (argv.includeIgnored) {
+                // Prune all: merge ignored into prunable
+                toPrune = allResults.map((r) => ({
+                    ...r,
+                    prunable: [...r.prunable, ...(r.ignored || [])],
+                }));
+            }
+
+            const deleteCount = toPrune.reduce(
+                (sum, r) => sum + r.prunable.length,
+                0,
+            );
+
+            const { deleted, failed } = await Spinner.prototype.simple(
+                `Deleting ${deleteCount} distribution(s)`,
+                () => deleteDistributions(toPrune),
+            );
+
+            console.log(
+                `\n  ${colorize("✓", "success")} Deleted ${colorize(deleted, "success")} distribution(s)${failed ? ` (${colorize(`${failed} failed`, "error")})` : ""}\n`,
+            );
+        }
+    },
+];