@maka/maka-cli 5.1.22 → 5.1.24

package/bundle/typescript/src/tools/aws/aws.class.js

@@ -0,0 +1,802 @@
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import { Actions } from '../actions/actions.class.js';
+import { Log } from '../log/log.class.js';
+import { MustBeInProjectError } from '../../error.js';
+import { ChangeResourceRecordSetsCommand, ChangeAction, RRType } from "@aws-sdk/client-route-53";
+import { EC2Client, DescribeInstancesCommand, RunInstancesCommand, TerminateInstancesCommand, CreateKeyPairCommand, AuthorizeSecurityGroupIngressCommand, CreateSecurityGroupCommand, RebootInstancesCommand, DescribeVpcsCommand, DescribeKeyPairsCommand, DeleteKeyPairCommand, DescribeSecurityGroupsCommand, DeleteSecurityGroupCommand, DescribeImagesCommand, DescribeSubnetsCommand } from "@aws-sdk/client-ec2"; // ES Modules import
+import { ECRClient, CreateRepositoryCommand, DeleteRepositoryCommand, GetAuthorizationTokenCommand, DescribeRepositoriesCommand } from "@aws-sdk/client-ecr";
+import { Route53, Route53Client, CreateHostedZoneCommand, } from "@aws-sdk/client-route-53";
+import { Route53Domains, CheckDomainAvailabilityCommand, RegisterDomainCommand, ListPricesCommand } from '@aws-sdk/client-route-53-domains';
+const client = new EC2Client({});
+const route53Client = new Route53Client({});
+const route53 = new Route53({});
+const route53Domains = new Route53Domains({});
+export class AWS {
+    static instance;
+    fsi;
+    cfg;
+    scaffold;
+    constructor(fsi, cfg, scaffold) {
+        this.fsi = fsi;
+        this.cfg = cfg;
+        this.scaffold = scaffold;
+    }
+    // Static method to get the singleton instance
+    static getInstance(fsi, cfg, scaffold) {
+        if (!AWS.instance) {
+            AWS.instance = new AWS(fsi, cfg, scaffold);
+        }
+        return AWS.instance;
+    }
+    async chooseSecurityGroup(sgName) {
+        try {
+            const { listIndexId, createdSgId, sgList } = await this.getSecurityGroups(sgName);
+            let selectedSgId = '';
+            if (createdSgId === '') {
+                Log.notice('** Available Security Groups **');
+                sgList.forEach(function (item) {
+                    if (item.name === sgName) {
+                        Log.notice('ID: ' + item.id + ' SG NAME: ' + item.name + ' SGID: ' + item.sgId);
+                    }
+                    else {
+                        Log.bright('ID: ' + item.id + ' SG NAME: ' + item.name + ' SGID: ' + item.sgId);
+                    }
+                });
+                const sgIdRes = await Actions.ask(`Please choose a SG to assign the instance to: [${listIndexId}] `) || listIndexId.toString();
+                sgList.forEach(function (item) {
+                    if (item.id === parseInt(sgIdRes)) {
+                        selectedSgId = item.sgId;
+                        Log.success('Setting SG ID to: ' + selectedSgId + '\n');
+                    }
+                });
+            }
+            else {
+                selectedSgId = createdSgId;
+                Log.success('Setting SG ID to: ' + selectedSgId + '\n');
+            }
+            if (selectedSgId === '') {
+                throw new Error('That was not an id in the list.');
+            }
+            return selectedSgId;
+        }
+        catch (e) {
+            Log.error(e);
+            throw e; // Re-throwing the error for handling elsewhere
+        }
+    }
+    async listAvailableAMIs() {
+        let AMI_ID = '';
+        try {
+            const ec2Client = new EC2Client({});
+            const commandInput = {
+                Filters: [
+                    { Name: "architecture", Values: ["x86_64"] },
+                    { Name: "virtualization-type", Values: ["hvm"] },
+                    { Name: "root-device-type", Values: ["ebs"] },
+                    { Name: "state", Values: ["available"] },
+                    { Name: "image-type", Values: ["machine"] },
+                    { Name: "description", Values: ["Canonical*Ubuntu*18.04*", "Canonical*Ubuntu*20.04*", "*Kali*"] } // Adjust version numbers as needed
+                ]
+            };
+            const command = new DescribeImagesCommand(commandInput);
+            const { Images } = await ec2Client.send(command);
+            if (Images && Images.length > 0) {
+                const today = new Date();
+                const oneMonthAgo = new Date(today.getTime() - (30 * 24 * 60 * 60 * 1000)); // 30 days ago
+                const imageList = Images.filter((item) => item.CreationDate &&
+                    !item.Description?.includes("UNSUPPORTED") && // Exclude images with "UNSUPPORTED" in description
+                    !item.Description?.includes("EKS") && // Exclude images with "EKS" in description
+                    new Date(item.CreationDate) > oneMonthAgo).map((item) => ({ amiId: item.ImageId, desc: item.Description, date: item.CreationDate }));
+                if (imageList.length > 0) {
+                    imageList.sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime());
+                    const topTenImages = imageList.slice(0, 4);
+                    const indexdList = topTenImages.map((item, index) => ({ id: index, amiId: item.amiId, desc: item.desc }));
+                    indexdList.forEach((item) => {
+                        Log.bright('ID: ' + item.id + ' AMIID: ' + item.amiId + ' DESCRIPTION: ' + item.desc);
+                    });
+                    const amiIdRes = await Actions.ask('Please choose an AMI ID to assign the instance to: [0] ') || "0";
+                    const selectedAMI = indexdList.find((item) => item.id === parseInt(amiIdRes));
+                    if (selectedAMI) {
+                        AMI_ID = selectedAMI.amiId;
+                        Log.success('Setting AMI ID to ' + AMI_ID + ' : ' + selectedAMI.desc);
+                    }
+                    else {
+                        throw Log.error('That was not an id in the list.');
+                    }
+                }
+                else {
+                    throw Log.error('No suitable images found within the last 30 days.');
+                }
+            }
+            else {
+                throw Log.error('No images found.');
+            }
+        }
+        catch (e) {
+            Log.error(e);
+        }
+        return AMI_ID;
+    }
+    async listAvailableSubnets() {
+        let SUBNET_ID = '';
+        try {
+            const ec2Client = new EC2Client({});
+            const commandInput = {};
+            const command = new DescribeSubnetsCommand(commandInput);
+            const { Subnets } = await ec2Client.send(command);
+            if (Subnets && Subnets.length > 0) {
+                const subnetList = Subnets.map((item, index) => ({
+                    id: index,
+                    cidr: item.CidrBlock,
+                    az: item.AvailabilityZone,
+                    subnetId: item.SubnetId
+                }));
+                subnetList.forEach((item) => {
+                    Log.bright('ID: ' + item.id + ' CIDR: ' + item.cidr + ' AZONE: ' + item.az + ' SUBNETID: ' + item.subnetId);
+                });
+                const subnetIdRes = await Actions.ask('Please choose a subnet ID to assign the instance to: [0] ') || "0";
+                const selectedSubnet = subnetList.find((item) => item.id === parseInt(subnetIdRes));
+                if (selectedSubnet) {
+                    SUBNET_ID = selectedSubnet.subnetId;
+                    Log.success('Setting Subnet ID to ' + SUBNET_ID);
+                }
+                else {
+                    throw Log.error('That was not an id in the list.');
+                }
+            }
+            else {
+                throw Log.error('No subnets found.');
+            }
+        }
+        catch (e) {
+            Log.error(e);
+        }
+        return SUBNET_ID;
+    }
+    async getSubnetCidr(subnetId) {
+        try {
+            const ec2Client = new EC2Client({});
+            const commandParams = {
+                Filters: [{ Name: "subnet-id", Values: [subnetId] }]
+            };
+            const command = new DescribeSubnetsCommand(commandParams);
+            const response = await ec2Client.send(command);
+            if (response.Subnets && response.Subnets.length > 0) {
+                return response.Subnets[0].CidrBlock || '';
+            }
+            else {
+                return '';
+            }
+        }
+        catch (error) {
+            Log.error(error);
+            return '';
+        }
+    }
+    async ecrCreateRepository(opts) {
+        try {
+            // Instantiate the ECRClient with the region provided in opts
+            const ecrClient = new ECRClient({ region: opts.region });
+            const input = {
+                "repositoryName": opts.name
+            };
+            const createEcrRepoCommand = new CreateRepositoryCommand(input);
+            const response = await ecrClient.send(createEcrRepoCommand);
+            // Optionally, log success message or return the response directly
+            Log.success(`Repository "${opts.name}" created successfully in ${opts.region}.`);
+            return response;
+        }
+        catch (e) {
+            Log.error(`Failed to create repository in ${opts.region}: ${e}`);
+            throw e; // Rethrow the error after logging
+        }
+    }
+    async listAllEcrRepositories(regionInput) {
+        const fullRegions = [
+            'us-east-1', 'us-east-2', 'us-west-1', 'us-west-2',
+            'ap-south-1', 'ap-northeast-3', 'ap-northeast-2',
+            'ap-southeast-1', 'ap-southeast-2', 'ap-northeast-1',
+            'ca-central-1', 'eu-central-1', 'eu-west-1', 'eu-west-2',
+            'eu-west-3', 'eu-north-1', 'sa-east-1',
+            'af-south-1', 'ap-east-1', 'ap-south-2', 'ap-southeast-3',
+            'ap-southeast-4', 'ca-west-1', 'eu-south-1', 'eu-south-2',
+            'eu-central-2', 'me-south-1', 'me-central-1', 'il-central-1'
+        ];
+        const limitedRegions = ['us-east-1', 'us-east-2', 'us-west-1', 'us-west-2'];
+        // Decide which set of regions to use based on the input
+        const regions = regionInput === "all" ? fullRegions :
+            regionInput ? regionInput.split(',') :
+                limitedRegions; // Default to limited regions if no specific input
+        let allRepositories = []; // To accumulate repositories from all regions
+        const spinner = Log.withSpinner();
+        for (const region of regions) {
+            spinner.start(`Processing ${region.trim()}...`);
+            const ecrClient = new ECRClient({ region: region.trim() });
+            try {
+                let nextToken = undefined;
+                do {
+                    const response = await Promise.race([
+                        ecrClient.send(new DescribeRepositoriesCommand({ nextToken })),
+                        new Promise((resolve) => setTimeout(() => resolve('timeout'), 2000))
+                    ]);
+                    if (response === 'timeout') {
+                        Log.warn(`Timeout while processing ${region.trim()}.`);
+                        break; // Skip to the next region
+                    }
+                    else if (response.repositories && response.repositories.length > 0) {
+                        allRepositories = allRepositories.concat(response.repositories.map(repo => ({
+                            name: repo.repositoryName,
+                            uri: repo.repositoryUri,
+                            region: region.trim()
+                        })));
+                    }
+                    nextToken = response.nextToken;
+                } while (nextToken);
+            }
+            catch (e) {
+                Log.error(`Failed in ${region.trim()}: ${e.message}`);
+            }
+            finally {
+                spinner.stop(); // Ensure the spinner is stopped before continuing
+            }
+        }
+        if (allRepositories.length > 0) {
+            console.log();
+            Log.success("Final list of ECR repositories:");
+            allRepositories.forEach(repo => {
+                Log.info(`Region: ${repo.region}, Name: ${repo.name}, URI: ${repo.uri}`);
+            });
+        }
+        else {
+            Log.warn("No ECR repositories found across all specified regions.");
+        }
+        return allRepositories;
+    }
+    async route53CreateHostedZone(domainName) {
+        try {
+            // Create a hosted zone (domain) in Route 53
+            const createHostedZoneParams = {
+                CallerReference: `${Date.now()}`,
+                Name: domainName
+            };
+            const createHostedZoneCommand = new CreateHostedZoneCommand(createHostedZoneParams);
+            await route53Client.send(createHostedZoneCommand);
+            Log.success('Hosted zone created successfully!');
+        }
+        catch (e) {
+            Log.error('Error creating hosted zone');
+            console.error(e);
+        }
+    }
+    async registerDomain(contact, domainName, duration, autoRenew) {
+        try {
+            const registerDomainParams = {
+                DomainName: domainName,
+                DurationInYears: duration,
+                AutoRenew: autoRenew,
+                AdminContact: contact,
+                RegistrantContact: contact,
+                TechContact: contact,
+                BillingContact: contact // Ensure BillingContact is included
+            };
+            const registerDomainCommand = new RegisterDomainCommand(registerDomainParams);
+            const response = await route53Domains.send(registerDomainCommand);
+            Log.notice(`The domain '${domainName}' has been registered successfully.`);
+            Log.notice(`Response: ${JSON.stringify(response)}`);
+        }
+        catch (error) {
+            Log.error(`There was an error registering the domain name`);
+            Log.warn(`From AWS:`);
+            if (error.$metadata) {
+                Log.error(` Status Code: ${error.$metadata.httpStatusCode}`);
+                Log.error(` Request ID: ${error.$metadata.requestId}`);
+            }
+            Log.error(`Error Message: ${error.message}`);
+            if (error.name === 'TLDRulesViolation') {
+                Log.error(error.message);
+            }
+            else {
+                Log.error('An unknown error occurred.');
+            }
+            Log.error(error);
+        }
+    }
+    async checkDomainAvailability(domainName) {
+        const checkAvailabilityParams = {
+            DomainName: domainName
+        };
+        const checkAvailabilityCommand = new CheckDomainAvailabilityCommand(checkAvailabilityParams);
+        const availabilityResponse = await route53Domains.send(checkAvailabilityCommand);
+        const available = availabilityResponse.Availability === 'AVAILABLE';
+        if (available) {
+            const tld = domainName.split('.').pop();
+            const params = {
+                MaxItems: 1,
+                Tld: tld
+            };
+            try {
+                const command = new ListPricesCommand(params);
+                const data = await route53Domains.send(command);
+                if (data && data.Prices && data.Prices[0]?.RegistrationPrice) {
+                    const cost = data.Prices[0].RegistrationPrice;
+                    return {
+                        available,
+                        cost
+                    };
+                }
+            }
+            catch (error) {
+                console.error('Error fetching domain pricing:', error);
+            }
+        }
+        return {
+            available,
+        };
+    }
+    async linkEC2ToRoute53(instanceId, publicIP, domainName) {
+        try {
+            // 2. Get Hosted Zone ID using the domain name
+            const hostedZones = await route53.listHostedZonesByName({ DNSName: domainName });
+            if (!hostedZones?.HostedZones) {
+                throw Log.error('Could not find hosted zone');
+            }
+            const hostedZoneId = hostedZones?.HostedZones[0].Id;
+            // 3. Create an A record in Route 53 pointing to the EC2 instance's public IP
+            const params = {
+                ChangeBatch: {
+                    Changes: [
+                        {
+                            Action: ChangeAction.UPSERT, // Use ChangeAction enum
+                            ResourceRecordSet: {
+                                Name: domainName,
+                                Type: RRType.A, // Use RRType enum
+                                TTL: 300,
+                                ResourceRecords: [
+                                    {
+                                        Value: publicIP
+                                    }
+                                ]
+                            }
+                        }
+                    ]
+                },
+                HostedZoneId: hostedZoneId
+            };
+            const command = new ChangeResourceRecordSetsCommand(params); // Create the command object
+            await route53.send(command); // Send the command using the client
+            Log.notice(`Successfully linked EC2 instance ${instanceId} to ${domainName}`);
+        }
+        catch (error) {
+            console.error('Error linking EC2 to Route 53:', error);
+        }
+    }
+    async getEcrLoginPassword({ awsAccountId, region }) {
+        const ecrClient = new ECRClient({ region });
+        try {
+            const command = new GetAuthorizationTokenCommand({ registryIds: [awsAccountId] });
+            const response = await ecrClient.send(command);
+            if (!response.authorizationData || response.authorizationData.length === 0) {
+                throw new Error('Authorization data is empty');
+            }
+            const authorizationData = response.authorizationData[0];
+            if (!authorizationData.authorizationToken) {
+                throw new Error('Authorization token is missing');
+            }
+            const base64Credentials = authorizationData.authorizationToken;
+            // Ensure that base64Credentials is defined before attempting to decode it
+            if (!base64Credentials) {
+                throw new Error("No credentials returned from AWS ECR");
+            }
+            const decodedCredentials = Buffer.from(base64Credentials, 'base64').toString();
+            const password = decodedCredentials.split(':')[1];
+            if (!password) {
+                throw new Error('Failed to decode password from authorization token');
+            }
+            return password;
+        }
+        catch (e) {
+            Log.error(e);
+            throw e; // Rethrow the error to be handled by the caller
+        }
+    }
+    async ecrDeleteRepository({ repoName, region }) {
+        const ecrClient = new ECRClient({ region });
+        try {
+            const command = new DeleteRepositoryCommand({
+                repositoryName: repoName,
+                // Note: Setting `force` to true will delete the repository even if it contains images
+                force: true
+            });
+            const response = await ecrClient.send(command);
+            return response; // You can return the response directly or process it as needed
+        }
+        catch (e) {
+            Log.error(e);
+            // Consider rethrowing the error or handling it based on your error management strategy
+            throw e;
+        }
+    }
+    async ec2create(opts) {
+        try {
+            const input = {
+                "BlockDeviceMappings": [
+                    {
+                        "DeviceName": "/dev/sdh",
+                        "Ebs": {
+                            "VolumeSize": 100
+                        }
+                    }
+                ],
+                "ImageId": opts.imageId,
+                "InstanceType": opts.type, // Cast opts.type to _InstanceType
+                "KeyName": opts.key,
+                "MaxCount": opts.maxCount,
+                "MinCount": opts.minCount,
+                "SecurityGroupIds": opts.sgIds.split(','),
+                "SubnetId": opts.subnet,
+                "TagSpecifications": [
+                    {
+                        "ResourceType": "instance",
+                        "Tags": opts.tags
+                    }
+                ]
+            };
+            if (opts.userData) {
+                input.UserData = `file://${opts.userData}`;
+            }
+            const ciCommand = new RunInstancesCommand(input);
+            const ciResponse = await client.send(ciCommand);
+            return ciResponse;
+        }
+        catch (e) {
+            Log.error(e);
+        }
+    }
+    async ec2terminateInstance(opts) {
+        try {
+            const input = {
+                "InstanceIds": [
+                    opts.instanceId
+                ]
+            };
+            const tiCommand = new TerminateInstancesCommand(input);
+            const tiResponse = await client.send(tiCommand);
+            return tiResponse;
+        }
+        catch (e) {
+            Log.error(e);
+            return {};
+        }
+    }
+    async createKeyPairEC2Key({ keyName, env }) {
+        const configDir = this.cfg.getAppConfigPath(env);
+        const filePath = path.join(configDir, '_keys', `${keyName}.pem.txt`);
+        try {
+            // if (this.fsi.isFile(filePath)) {
+            //   throw `A PEM file exists at this location: ${filePath}`;
+            // }
+            const input = {
+                "KeyName": keyName
+            };
+            const ckpCommand = new CreateKeyPairCommand(input);
+            const ckpResult = await client.send(ckpCommand);
+            const key = ckpResult.KeyMaterial;
+            if (key) {
+                await this.fsi.createFile({
+                    filePath,
+                    data: key
+                });
+                execSync('chmod 400 ' + filePath, { stdio: 'ignore' });
+                const isFileCheck = this.fsi.isFile(filePath);
+                if (isFileCheck) {
+                    Log.success('Pem key saved to ' + filePath);
+                    return { keyName, filePath };
+                }
+                else {
+                    throw new Error('Error saving pem file, aborting');
+                }
+            }
+            else {
+                throw new Error('Error generating key pair');
+            }
+        }
+        catch (e) {
+            Log.error(e);
+            process.exit(1);
+        }
+    }
+    async ingressRule({ port, groupId }) {
+        const input = {
+            "GroupId": groupId,
+            "IpPermissions": [
+                {
+                    "FromPort": port,
+                    "IpProtocol": "tcp",
+                    "IpRanges": [
+                        {
+                            "CidrIp": "0.0.0.0/0",
+                            "Description": ""
+                        }
+                    ],
+                    "ToPort": port
+                }
+            ]
+        };
+        const ingressRulecommand = new AuthorizeSecurityGroupIngressCommand(input);
+        Log.notice(`Port ${port} opened!`);
+        return await client.send(ingressRulecommand);
+    }
+    async ec2createSG(opts) {
+        try {
+            if (opts.description === '') {
+                opts.description = await Actions.ask('Description:') || 'Web App';
+            }
+            const input = {
+                "Description": opts.description,
+                "GroupName": opts.name,
+                "VpcId": opts.vpcId
+            };
+            const csgCommand = new CreateSecurityGroupCommand(input);
+            const csgResponse = await client.send(csgCommand);
+            const { GroupId } = csgResponse;
+            if (!csgResponse) {
+                throw new Error('AWS was not able to validate the provided access credentials');
+            }
+            if (GroupId) {
+                opts.sgPorts.forEach((port) => {
+                    this.ingressRule({ port: parseInt(port), groupId: GroupId });
+                });
+            }
+            Log.success(`Created: ${GroupId} NAME: ${opts.name}`);
+        }
+        catch (e) {
+            Log.error(e);
+            return false;
+        }
+        return true;
+    }
+    async ec2describeKeys(opts) {
+        const keysList = [];
+        try {
+            const input = {};
+            const dkpCommand = new DescribeKeyPairsCommand(input);
+            const dkpResponse = await client.send(dkpCommand);
+            if (!dkpResponse) {
+                throw ('AWS was not able to validate the provided access credentials');
+            }
+            const { KeyPairs } = dkpResponse;
+            if (KeyPairs) {
+                KeyPairs?.forEach((item, index) => {
+                    if (item.KeyName) {
+                        keysList.push({ id: index, name: item.KeyName });
+                    }
+                });
+                if (keysList.length > 0) {
+                    keysList.forEach((item) => {
+                        if (item.name === opts?.suggestion) {
+                            Log.success('ID: ' + item.id + ' NAME: ' + item.name);
+                        }
+                        else {
+                            Log.notice('ID: ' + item.id + ' NAME: ' + item.name);
+                        }
+                    });
+                }
+            }
+            else {
+                Log.error('You have no key-pairs, please create one. (maka aws create-key-pair --env).');
+            }
+        }
+        catch (e) {
+            Log.error(e);
+        }
+        return keysList;
+    }
+    async deleteKeyPair(keyName) {
+        try {
+            const input = {
+                KeyName: keyName,
+            };
+            const dkpCommand = new DeleteKeyPairCommand(input);
+            await client.send(dkpCommand);
+        }
+        catch (e) {
+            Log.error(e);
+            process.exit(1);
+        }
+    }
+    async ec2describeInstances() {
+        const responseObject = [];
+        try {
+            const input = {
+                "Filters": [
+                    {
+                        "Name": "tag:created-by",
+                        "Values": [
+                            "maka-cli"
+                        ]
+                    }
+                ]
+            };
+            const diCommand = new DescribeInstancesCommand(input);
+            const response = await client.send(diCommand);
+            response.Reservations?.forEach((reservation, index) => {
+                if (reservation?.Instances) {
+                    const { InstanceId, PublicIpAddress, PrivateIpAddress, State, KeyName, Tags } = reservation.Instances[0];
+                    const EnvTag = Tags?.find(({ Key }) => Key === 'environment');
+                    responseObject.push({
+                        id: index,
+                        instanceId: InstanceId,
+                        privateIp: PrivateIpAddress,
+                        publicIp: PublicIpAddress,
+                        status: State?.Name,
+                        name: KeyName,
+                        env: EnvTag?.Value
+                    });
+                }
+            });
+            if (responseObject.length > 0) {
+                responseObject.forEach((item) => {
+                    const printLine = 'ID: ' + item.id + ' NAME: ' + item.name + ' ENV: ' + item.env + ' STATUS: ' + item.status + ' INSTANCE_ID: ' + item.instanceId + ' PUB_IP: ' + item.publicIp + ' PRIV_IP: ' + item.privateIp;
+                    if (item.status === 'terminated') {
+                        Log.error(printLine);
+                    }
+                    else if (item.status === 'running') {
+                        Log.success(printLine);
+                    }
+                    else {
+                        Log.notice(printLine);
+                    }
+                });
+            }
+            else {
+                Log.error('You have no instances created by maka-cli.  Please reivew your AWS console manually!!!');
+            }
+        }
+        catch (e) {
+            Log.error(e);
+        }
+        return responseObject;
+    }
+    async ec2rebootInstance(opts) {
+        try {
+            const input = {
+                "InstanceIds": [
+                    opts.instanceId
+                ]
+            };
+            const rbiCommand = new RebootInstancesCommand(input);
+            const rbiResponse = await client.send(rbiCommand);
+            if (rbiResponse['$metadata'].httpStatusCode === 200) {
+                Log.success(`Instance rebooted!`);
+            }
+            return rbiResponse;
+        }
+        catch (e) {
+            Log.error(e);
+        }
+    }
+    async chooseVPC() {
+        let VPC_ID = '';
+        Log.notice('** Available  VPCs **');
+        const dvpcCommand = new DescribeVpcsCommand({});
+        const dvpcResponse = await client.send(dvpcCommand);
+        const { Vpcs } = dvpcResponse;
+        const vpcList = [];
+        if (Vpcs) {
+            Vpcs.forEach((item, index) => {
+                if (item.VpcId && item.CidrBlock) {
+                    vpcList.push({ id: index, vpcId: item.VpcId, cidr: item.CidrBlock });
+                }
+            });
+        }
+        vpcList.forEach(function (item) {
+            console.log(`ID: ${item.id} VPCID: ${item.vpcId} CIDR: ${item.cidr}`);
+        });
+        const vpcIdRes = await Actions.ask('Please choose a VPC: [0] ') || 0;
+        vpcList.forEach(function (item) {
+            if (item.id == vpcIdRes) {
+                VPC_ID = item.vpcId;
+                Log.success('[+] Setting VPC ID to: ' + VPC_ID + '\n');
+            }
+        });
+        if (VPC_ID === '') {
+            Log.error('That was not an id in the list.');
+            return '';
+        }
+        return VPC_ID;
+    }
+    async chooseInstance() {
+        const instances = await this.ec2describeInstances();
+        if (instances.length === 0) {
+            Log.error('No instances found');
+            return null;
+        }
+        const choice = await Actions.ask('[?] Please choose an instance ID: ');
+        if (!choice) {
+            Log.error('Invalid choice');
+            process.exit(0);
+        }
+        const instance = instances.find(({ id }) => { return id == parseInt(choice); }) || null;
+        return instance;
+    }
+    async createKeyPair({ env }) {
+        try {
+            const projectConfig = this.cfg.getMakaProjectConfig();
+            if (!projectConfig) {
+                throw MustBeInProjectError;
+            }
+            const { appName } = projectConfig;
+            const defaultAppName = `${appName}-${env}`;
+            const keyName = await Actions.ask(`Key Name: [${defaultAppName}] `) || defaultAppName;
+            const { filePath } = await this.createKeyPairEC2Key({ keyName, env });
+            // update the ssh file.
+            const updateSSHConfig = await Actions.confirm('Would you like to update the ssh.json config file?', true);
+            if (updateSSHConfig) {
+                try {
+                    const sshJsonConfig = path.join('config', env, 'ssh.json');
+                    if (!this.fsi.isFile(sshJsonConfig)) {
+                        await this.scaffold.template({
+                            srcPath: 'config/ssh.json',
+                            destPath: sshJsonConfig,
+                            context: {
+                                app: keyName
+                            }
+                        });
+                    }
+                    const sshConfig = fs.readFileSync(path.join('config', env, 'ssh.json'), 'utf8');
+                    const sshConfigJson = JSON.parse(sshConfig);
+                    sshConfigJson.pem = path.join('_keys', `${keyName}.pem.txt`);
+                    fs.writeFileSync(path.join('config', env, 'ssh.json'), JSON.stringify(sshConfigJson, null, 2));
+                }
+                catch (e) {
+                    Log.error(e);
+                    Log.error('You will need to update the ssh.json file yourself.');
+                }
+            }
+            return { keyName, filePath };
+        }
+        catch (e) {
+            Log.error(e);
+            process.exit(1);
+        }
+    }
+    async getSecurityGroups(name) {
+        const sgList = [];
+        const input = {};
+        const dsgCommand = new DescribeSecurityGroupsCommand(input);
+        const dsgResponse = await client.send(dsgCommand);
+        const { SecurityGroups } = dsgResponse;
+        if (SecurityGroups) {
+            SecurityGroups.forEach(function (item, index) {
+                if (item.GroupName && item.GroupId) {
+                    sgList.push({ id: index, name: item.GroupName, sgId: item.GroupId, });
+                }
+            });
+        }
+        let createdSgId = '';
+        let listIndexId = 0;
+        sgList.forEach(function (item) {
+            if (item.name === name) {
+                createdSgId = item.sgId;
+                listIndexId = item.id;
+            }
+        });
+        return { sgList, createdSgId, listIndexId };
+    }
+    async deleteSecurityGroup(groupId) {
+        try {
+            const input = {
+                "GroupId": groupId
+            };
+            const dsgCommand = new DeleteSecurityGroupCommand(input);
+            await client.send(dsgCommand);
+        }
+        catch (e) {
+            Log.error(e);
+            process.exit(1);
+        }
+    }
+}
+//# sourceMappingURL=aws.class.js.map