@fishawack/lab-env 5.7.0-beta.1 → 5.7.0-beta.3

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",
@@ -228,19 +411,49 @@ module.exports = [
                     },
                 ])),
             };
+
+            if (answers.framework === "laravel") {
+                answers = {
+                    ...answers,
+                    ...(await inquirer.prompt([
+                        {
+                            type: "confirm",
+                            name: "opensearch",
+                            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,
+                        },
+                    ])),
+                };
+            }
         }
 
         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 = [];
@@ -296,78 +509,64 @@ module.exports = [
         // Set AWS client defaults before any AWS operations
         setAWSClientDefaults(answers.client, answers.region);
 
-        // Snapshot restore prompt — only if database requested, before preflight
-        let snapshot = null;
-
-        if (answers.database) {
-            const { restore } = await inquirer.prompt([
-                {
-                    type: "confirm",
-                    name: "restore",
-                    message: "Restore database from an existing snapshot?",
-                    default: false,
-                },
-            ]);
-
-            if (restore) {
-                const snapshots = await aws.rds.listManualSnapshots();
-
-                if (snapshots.length) {
-                    const { selected } = await inquirer.prompt([
-                        {
-                            type: "list",
-                            name: "selected",
-                            message: "Select a snapshot to restore from",
-                            choices: snapshots.map((s) => ({
-                                name: `${s.DBSnapshotIdentifier} (source: ${s.DBInstanceIdentifier}, created: ${new Date(s.SnapshotCreateTime).toLocaleDateString()})`,
-                                value: s.DBSnapshotIdentifier,
-                            })),
-                        },
-                    ]);
-
-                    snapshot = selected;
-                } else {
-                    new utilities.Spinner(
-                        "No manual snapshots found, creating a fresh database",
-                        true,
-                    ).ora.info();
-                }
-            }
-        }
-
         // Pre-flight check for existing resources
-        let existingSecrets = { app: null, storage: null, database: null };
+        let existingSecrets = {
+            app: null,
+            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;
 
         if (answers.stack === "fullstack") {
-            const { conflicts, existing } = await aws.fullstackPreflight(
+            const { existing } = await aws.fullstackPreflight(
                 slug,
                 _.repoSafe,
                 branch,
                 {
                     storage: answers.storage,
                     database: answers.database,
+                    opensearch: answers.opensearch,
+                    cache: answers.cache,
                 },
             );
 
-            if (conflicts.length) {
-                conflicts.forEach((c) =>
-                    console.log(utilities.colorize(`\n  ✗ ${c}`, "error")),
-                );
+            if (
+                existing.environment &&
+                existing.environment.Status !== "Ready"
+            ) {
                 console.log(
                     utilities.colorize(
-                        "\nProvisioning aborted due to existing resources.\n",
+                        `\n  ✗ EB environment "${slug}" is currently ${existing.environment.Status}, cannot re-provision\n`,
                         "error",
                     ),
                 );
                 process.exit(1);
             }
 
+            if (existing.environment) {
+                new utilities.Spinner(
+                    "EB environment already exists, skipping creation",
+                    true,
+                ).ora.info();
+                existingEnvironment = existing.environment;
+            }
+
             if (existing.storage) {
                 new utilities.Spinner(
                     "S3 bucket already exists, skipping storage creation",
                     true,
                 ).ora.info();
-                answers.storage = false;
+                existingResources.storage = true;
             }
 
             if (existing.database) {
@@ -375,7 +574,60 @@ module.exports = [
                     "RDS instance already exists, skipping database creation",
                     true,
                 ).ora.info();
-                answers.database = false;
+                existingResources.database = true;
+            }
+
+            if (existing.opensearch) {
+                new utilities.Spinner(
+                    "OpenSearch domain already exists, skipping creation",
+                    true,
+                ).ora.info();
+                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([
+                    {
+                        type: "confirm",
+                        name: "restore",
+                        message: "Restore database from an existing snapshot?",
+                        default: false,
+                    },
+                ]);
+
+                if (restore) {
+                    const snapshots = await aws.rds.listManualSnapshots();
+
+                    if (snapshots.length) {
+                        const { selected } = await inquirer.prompt([
+                            {
+                                type: "list",
+                                name: "selected",
+                                message: "Select a snapshot to restore from",
+                                choices: snapshots.map((s) => ({
+                                    name: `${s.DBSnapshotIdentifier} (source: ${s.DBInstanceIdentifier}, created: ${new Date(s.SnapshotCreateTime).toLocaleDateString()})`,
+                                    value: s.DBSnapshotIdentifier,
+                                })),
+                            },
+                        ]);
+
+                        snapshot = selected;
+                    } else {
+                        new utilities.Spinner(
+                            "No manual snapshots found, creating a fresh database",
+                            true,
+                        ).ora.info();
+                    }
+                }
             }
 
             existingSecrets = existing.secrets;
@@ -400,6 +652,241 @@ module.exports = [
                     true,
                 ).ora.info();
             }
+
+            if (existingSecrets.opensearch) {
+                new utilities.Spinner(
+                    "OpenSearch secret already exists, reusing existing values",
+                    true,
+                ).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 = {
+                    ...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([
+                        {
+                            type: "list",
+                            name: "elbScheme",
+                            message: "Load balancer visibility?",
+                            choices: ["public", "internal"],
+                        },
+                    ])),
+                };
+            }
+
+            // App name and domain prompts — only for new Laravel environments
+            if (!existingEnvironment && answers.framework === "laravel") {
+                answers = {
+                    ...answers,
+                    ...(await inquirer.prompt([
+                        {
+                            type: "input",
+                            name: "appName",
+                            message: "What is the app name?",
+                            default: _.repoSafe
+                                .replace(/-/g, " ")
+                                .replace(/^./, (c) => c.toUpperCase()),
+                            validate: (v) =>
+                                /^[a-zA-Z0-9 ]+$/.test(v) ||
+                                "Alphanumeric characters and spaces only",
+                        },
+                        {
+                            type: "input",
+                            name: "appDomain",
+                            message:
+                                "What domain will this site be served at? (DNS must be configured manually)",
+                            filter: (v) =>
+                                v
+                                    .replace(/^https?:\/\//, "")
+                                    .replace(/\/+$/, ""),
+                            validate: (v) =>
+                                v.length > 0 || "Domain is required",
+                        },
+                    ])),
+                };
+
+                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 {
@@ -408,8 +895,9 @@ 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,
@@ -422,18 +910,28 @@ 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",
+                    existingEnvironment,
+                    existingResources,
+                    answers.appName,
+                    answers.appDomain,
+                    answers.certArn,
+                    answers.instanceType,
+                    answers.mailData,
                 );
             }
         } catch (e) {
@@ -448,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;
         }