@fishawack/lab-env 5.7.0-beta.2 → 5.7.0-beta.4

package/commands/create/cmds/provision.js

@@ -18,6 +18,11 @@ module.exports = [
             describe: "Branch to configure",
             type: "string",
         });
+        yargs.option("green-blue", {
+            alias: "g",
+            describe: "Clone an existing environment (pass source branch name)",
+            type: "string",
+        });
     },
     async (argv) => {
         let branch = argv.branch || _.branch;
@@ -38,6 +43,190 @@ module.exports = [
             process.exit(1);
         }
 
+        // Green/Blue clone flow — entirely separate path
+        if (argv.greenBlue) {
+            let gbAnswers = await inquirer.prompt([client, region]);
+
+            setAWSClientDefaults(gbAnswers.client, gbAnswers.region);
+
+            // List existing EB applications
+            const applications = await aws.elasticbeanstalk.listApplications();
+
+            if (!applications.length) {
+                console.log(
+                    utilities.colorize(
+                        "\n  ✗ No EB applications found in this account/region\n",
+                        "error",
+                    ),
+                );
+                process.exit(1);
+            }
+
+            // List all environments across applications
+            let allEnvironments = [];
+            for (const app of applications) {
+                const envs = await aws.elasticbeanstalk.listEnvironments(
+                    app.ApplicationName,
+                );
+                allEnvironments = allEnvironments.concat(
+                    envs.map((e) => ({
+                        ...e,
+                        ApplicationName: app.ApplicationName,
+                    })),
+                );
+            }
+
+            if (!allEnvironments.length) {
+                console.log(
+                    utilities.colorize(
+                        "\n  ✗ No active EB environments found\n",
+                        "error",
+                    ),
+                );
+                process.exit(1);
+            }
+
+            const { sourceEnv } = await inquirer.prompt([
+                {
+                    type: "list",
+                    name: "sourceEnv",
+                    message: "Which environment should be cloned?",
+                    choices: allEnvironments.map((e) => ({
+                        name: `${e.EnvironmentName} (${e.Status})`,
+                        value: e,
+                    })),
+                },
+            ]);
+
+            // Validate branch doesn't conflict with source
+            const sourceSlug = sourceEnv.EnvironmentName;
+            const newSlug = aws.slug(
+                _.repoSafe,
+                gbAnswers.client,
+                branch,
+                "eb",
+            );
+
+            if (newSlug === sourceSlug) {
+                const { newBranch } = await inquirer.prompt([
+                    {
+                        type: "input",
+                        name: "newBranch",
+                        message:
+                            "Branch conflicts with source. Enter a different branch name:",
+                        default: `${branch}-green`,
+                        validate: (input) => {
+                            const slug = aws.slug(
+                                _.repoSafe,
+                                gbAnswers.client,
+                                input,
+                                "eb",
+                            );
+                            if (slug === sourceSlug) {
+                                return "Branch still conflicts with source environment";
+                            }
+                            return true;
+                        },
+                    },
+                ]);
+                branch = newBranch;
+            }
+
+            const slug = aws.slug(_.repoSafe, gbAnswers.client, branch, "eb");
+
+            // Check the clone doesn't already exist
+            const { Environments } =
+                await aws.elasticbeanstalk.describeEnvironment(slug);
+            const active = (Environments || []).filter(
+                (e) => e.Status !== "Terminated",
+            );
+            if (active.length) {
+                console.log(
+                    utilities.colorize(
+                        `\n  ✗ Environment "${slug}" already exists (${active[0].Status})\n`,
+                        "error",
+                    ),
+                );
+                process.exit(1);
+            }
+
+            const environmentChoices = ["production", "staging", "test"];
+            const defaultEnvironment =
+                environmentChoices.find((e) =>
+                    branch.toLowerCase().includes(e),
+                ) || "test";
+
+            // Get environment tag from source
+            const sourceTags = await aws.elasticbeanstalk.getEnvironmentTags(
+                sourceEnv.EnvironmentArn,
+            );
+            const sourceEnvTag = sourceTags.find(
+                (t) => t.Key === "environment",
+            );
+            const envTagValue = sourceEnvTag
+                ? sourceEnvTag.Value
+                : defaultEnvironment;
+
+            const tags = [
+                { Key: "repository", Value: _.repo },
+                { Key: "environment", Value: envTagValue },
+                { Key: "branch", Value: branch },
+                { Key: "automated", Value: "true" },
+                { Key: "cloned-from", Value: sourceEnv.EnvironmentName },
+            ];
+
+            try {
+                const infastructure = await aws.fullstackClone(
+                    slug,
+                    tags,
+                    _.repoSafe,
+                    branch,
+                    sourceEnv.ApplicationName,
+                    sourceEnv.EnvironmentName,
+                    sourceEnv.VersionLabel,
+                    argv.greenBlue,
+                );
+
+                const config = {};
+                config[branch] = {
+                    deploy: {
+                        url: infastructure.url,
+                        location: "/var/www/html",
+                        "aws-eb": infastructure.environment,
+                        environment: envTagValue,
+                        paths: infastructure.paths,
+                        "cloned-from": sourceEnv.EnvironmentName,
+                    },
+                };
+
+                if (infastructure.copy) {
+                    config[branch].copy = infastructure.copy;
+                }
+
+                let stringify = JSON.stringify(config, null, 4);
+                let output = stringify
+                    .substring(1, stringify.length - 1)
+                    .trim();
+                utilities.copyToClipboard(output);
+                console.log(
+                    utilities.colorize(
+                        `\n${output}\n\n(copied to clipboard)`,
+                        "title",
+                    ),
+                );
+            } catch (e) {
+                console.log(e.message);
+                process.exit(1);
+            }
+
+            return;
+        }
+
+        const environmentChoices = ["production", "staging", "test"];
+        const defaultEnvironment =
+            environmentChoices.find((e) => branch.toLowerCase().includes(e)) ||
+            "test";
+
         let answers = await inquirer.prompt([stack]);
 
         // Prompt for redirects if static stack and no existing redirects
@@ -207,12 +396,6 @@ module.exports = [
                             value: "default",
                         }),
                     },
-                    {
-                        type: "list",
-                        name: "availability",
-                        message: "What availability is required?",
-                        choices: ["low", "high"],
-                    },
                     region,
                     {
                         type: "confirm",
@@ -239,6 +422,18 @@ module.exports = [
                             message: "Does this site need OpenSearch?",
                             default: false,
                         },
+                        {
+                            type: "confirm",
+                            name: "cache",
+                            message: "Does this site need cache (Valkey)?",
+                            default: false,
+                        },
+                        {
+                            type: "confirm",
+                            name: "mail",
+                            message: "Does this site need email (SES)?",
+                            default: false,
+                        },
                     ])),
                 };
             }
@@ -246,15 +441,19 @@ module.exports = [
 
         answers = {
             ...answers,
-            ...(await inquirer.prompt([
-                client,
-                {
-                    type: "confirm",
-                    name: "protected",
-                    message: "Should the site be password protected?",
-                    default: true,
-                },
-            ])),
+            ...(await inquirer.prompt(
+                answers.stack === "static"
+                    ? [
+                          client,
+                          {
+                              type: "confirm",
+                              name: "protected",
+                              message: "Should the site be password protected?",
+                              default: true,
+                          },
+                      ]
+                    : [client],
+            )),
         };
 
         let credentials = [];
@@ -316,12 +515,15 @@ module.exports = [
             storage: null,
             database: null,
             opensearch: null,
+            cache: null,
+            mail: null,
         };
         let existingEnvironment = false;
         let existingResources = {
             storage: false,
             database: false,
             opensearch: false,
+            cache: false,
         };
         let snapshot = null;
 
@@ -334,6 +536,7 @@ module.exports = [
                     storage: answers.storage,
                     database: answers.database,
                     opensearch: answers.opensearch,
+                    cache: answers.cache,
                 },
             );
 
@@ -382,6 +585,14 @@ module.exports = [
                 existingResources.opensearch = true;
             }
 
+            if (existing.cache) {
+                new utilities.Spinner(
+                    "ElastiCache cluster already exists, skipping creation",
+                    true,
+                ).ora.info();
+                existingResources.cache = true;
+            }
+
             // Snapshot restore prompt — only if database is needed and doesn't already exist
             if (answers.database && !existing.database) {
                 const { restore } = await inquirer.prompt([
@@ -449,8 +660,144 @@ module.exports = [
                 ).ora.info();
             }
 
+            if (existingSecrets.cache) {
+                new utilities.Spinner(
+                    "Cache secret already exists, reusing existing values",
+                    true,
+                ).ora.info();
+            }
+
+            if (existingSecrets.mail) {
+                new utilities.Spinner(
+                    "Mail secret already exists, reusing existing values",
+                    true,
+                ).ora.info();
+            }
+
+            // SES detail prompts — only if mail requested and not already configured
+            if (answers.mail && !existingSecrets.mail) {
+                const identities = await aws.ses.listVerifiedIdentities();
+
+                if (!identities.length) {
+                    new utilities.Spinner(
+                        "No verified SES identities found, skipping email setup",
+                        true,
+                    ).ora.warn();
+                    answers.mail = false;
+                } else {
+                    const defaultIdentity = answers.appDomain
+                        ? identities.find(
+                              (id) =>
+                                  answers.appDomain.endsWith(id) ||
+                                  id === answers.appDomain,
+                          ) || identities[0]
+                        : identities[0];
+
+                    const { sesIdentity } = await inquirer.prompt([
+                        {
+                            type: "list",
+                            name: "sesIdentity",
+                            message:
+                                "Which verified SES domain should be used?",
+                            choices: identities,
+                            default: defaultIdentity,
+                        },
+                    ]);
+
+                    const { mailFromAddress } = await inquirer.prompt([
+                        {
+                            type: "input",
+                            name: "mailFromAddress",
+                            message: "Mail from address:",
+                            default: `noreply@${sesIdentity}`,
+                            validate: (input) => {
+                                if (!input.includes("@")) {
+                                    return "Must be a valid email address";
+                                }
+                                const domain = input.split("@")[1];
+                                if (
+                                    domain === sesIdentity ||
+                                    domain.endsWith(`.${sesIdentity}`)
+                                ) {
+                                    return true;
+                                }
+                                return `Address must be under the verified identity ${sesIdentity}`;
+                            },
+                        },
+                    ]);
+
+                    const { mailFromName } = await inquirer.prompt([
+                        {
+                            type: "input",
+                            name: "mailFromName",
+                            message: "Mail from name:",
+                            default:
+                                answers.appName ||
+                                _.repoSafe
+                                    .replace(/-/g, " ")
+                                    .replace(/^./, (c) => c.toUpperCase()),
+                            validate: (input) =>
+                                !!input.length || "From name is required",
+                        },
+                    ]);
+
+                    answers.mailData = {
+                        fromAddress: mailFromAddress,
+                        fromName: mailFromName,
+                    };
+                }
+            }
+
+            // Resolve environment tag
+            if (existingEnvironment) {
+                const envTags = await aws.elasticbeanstalk.getEnvironmentTags(
+                    existingEnvironment.EnvironmentArn,
+                );
+                const envTag = envTags.find((t) => t.Key === "environment");
+                answers.environment = envTag
+                    ? envTag.Value
+                    : defaultEnvironment;
+                new utilities.Spinner(
+                    `Using existing environment tag: ${answers.environment}`,
+                    true,
+                ).ora.info();
+            } else {
+                answers = {
+                    ...answers,
+                    ...(await inquirer.prompt([
+                        {
+                            type: "list",
+                            name: "environment",
+                            message: "What environment is this?",
+                            choices: environmentChoices,
+                            default: defaultEnvironment,
+                        },
+                    ])),
+                };
+            }
+
             // EB-specific prompts — only for new environments
-            if (!existingEnvironment && answers.availability === "high") {
+            if (!existingEnvironment) {
+                answers = {
+                    ...answers,
+                    ...(await inquirer.prompt([
+                        {
+                            type: "list",
+                            name: "instanceType",
+                            message: "What instance size is required?",
+                            choices: [
+                                { name: "Small", value: "t3.small" },
+                                { name: "Medium", value: "t3.medium" },
+                                { name: "Large", value: "t3.large" },
+                                { name: "XLarge", value: "t3.xlarge" },
+                            ],
+                            default: "t3.small",
+                        },
+                    ])),
+                };
+            }
+
+            if (!existingEnvironment) {
                 answers = {
                     ...answers,
                     ...(await inquirer.prompt([
@@ -473,7 +820,9 @@ module.exports = [
                             type: "input",
                             name: "appName",
                             message: "What is the app name?",
-                            default: _.repoSafe,
+                            default: _.repoSafe
+                                .replace(/-/g, " ")
+                                .replace(/^./, (c) => c.toUpperCase()),
                             validate: (v) =>
                                 /^[a-zA-Z0-9 ]+$/.test(v) ||
                                 "Alphanumeric characters and spaces only",
@@ -493,50 +842,62 @@ module.exports = [
                     ])),
                 };
 
-                // ACM cert selection — only for high availability (ALB)
-                if (answers.availability === "high") {
-                    const matchingCerts =
-                        await aws.acm.findCertificatesForDomain(
-                            answers.appDomain,
-                        );
-
-                    if (matchingCerts.length) {
-                        answers = {
-                            ...answers,
-                            ...(await inquirer.prompt([
-                                {
-                                    type: "list",
-                                    name: "certArn",
-                                    message:
-                                        "Which ACM certificate should be used for HTTPS?",
-                                    choices: [
-                                        ...matchingCerts.map((c) => ({
-                                            name: c.DomainName,
-                                            value: c.CertificateArn,
-                                        })),
-                                        { name: "None", value: null },
-                                    ],
-                                },
-                            ])),
-                        };
-                    } else {
-                        new utilities.Spinner(
-                            `No ACM certificates match ${answers.appDomain}, HTTPS listener must be configured manually`,
-                            true,
-                        ).ora.info();
-                    }
+                const matchingCerts = await aws.acm.findCertificatesForDomain(
+                    answers.appDomain,
+                );
+
+                if (matchingCerts.length) {
+                    answers = {
+                        ...answers,
+                        ...(await inquirer.prompt([
+                            {
+                                type: "list",
+                                name: "certArn",
+                                message:
+                                    "Which ACM certificate should be used for HTTPS?",
+                                choices: [
+                                    ...matchingCerts.map((c) => ({
+                                        name: c.DomainName,
+                                        value: c.CertificateArn,
+                                    })),
+                                    { name: "None", value: null },
+                                ],
+                            },
+                        ])),
+                    };
+                } else {
+                    new utilities.Spinner(
+                        `No ACM certificates match ${answers.appDomain}, HTTPS listener must be configured manually`,
+                        true,
+                    ).ora.info();
                 }
             }
         }
 
+        if (answers.stack === "static") {
+            answers = {
+                ...answers,
+                ...(await inquirer.prompt([
+                    {
+                        type: "list",
+                        name: "environment",
+                        message: "What environment is this?",
+                        choices: environmentChoices,
+                        default: defaultEnvironment,
+                    },
+                ])),
+            };
+        }
+
         try {
             if (answers.stack === "static") {
                 infastructure = await aws.static(
                     slug,
                     [
                         { Key: "repository", Value: _.repo },
-                        { Key: "environment", Value: branch },
-                        { Key: "automated", Value: true },
+                        { Key: "environment", Value: answers.environment },
+                        { Key: "branch", Value: branch },
+                        { Key: "automated", Value: "true" },
                     ],
                     credentials,
                     _.repoSafe,
@@ -549,17 +910,18 @@ module.exports = [
                     slug,
                     [
                         { Key: "repository", Value: _.repo },
-                        { Key: "environment", Value: branch },
-                        { Key: "automated", Value: true },
+                        { Key: "environment", Value: answers.environment },
+                        { Key: "branch", Value: branch },
+                        { Key: "automated", Value: "true" },
                     ],
-                    credentials,
                     _.repoSafe,
                     branch,
                     answers.framework,
-                    answers.availability,
                     answers.database,
                     answers.storage,
                     answers.opensearch,
+                    answers.cache,
+                    answers.mail,
                     existingSecrets,
                     snapshot,
                     answers.elbScheme || "public",
@@ -568,6 +930,8 @@ module.exports = [
                     answers.appName,
                     answers.appDomain,
                     answers.certArn,
+                    answers.instanceType,
+                    answers.mailData,
                 );
             }
         } catch (e) {
@@ -582,16 +946,22 @@ module.exports = [
                       location: infastructure.bucket.slice(1), // Remove / from start
                       "aws-s3": answers.client,
                       "aws-cloudfront": infastructure.cloudfront,
+                      environment: answers.environment,
                   }
                 : {
                       url: infastructure.url,
                       location: "/var/www/html",
                       "aws-eb": infastructure.environment,
+                      environment: answers.environment,
                       paths: infastructure.paths,
                   };
 
         config[branch] = { deploy };
 
+        if (infastructure.copy) {
+            config[branch].copy = infastructure.copy;
+        }
+
         if (credentials.length) {
             config[branch].deploy.users = credentials;
         }