@maka/maka-cli 5.2.10 → 5.3.0

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

@@ -1,802 +0,0 @@
-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