@agilecustoms/envctl 0.9.0 → 0.11.0

package/README.md

@@ -33,7 +33,7 @@ npm view @agilecustoms/envctl version # show latest version available (without i
 `env-api` is a microservice hosted in 'maintenance' account and working as garbage collector: every environment first
 created in `env-api` and then 'managed' by `env-api`: it deletes env when it is not in use anymore OR can extend lifetime.
 Creation API yields unique ID, so you can safely manage env (delete, extend lifetime) via this ID. But creation API
-need to be secured. There are two main use cases:
+needs to be secured. There are two main use cases:
 1. create environment from CI (mainly ephemeral envs)
 2. create env from dev machine
 

package/dist/client/ProcessRunner.js

@@ -9,7 +9,9 @@ export class ProcessRunner {
         return this.run(scriptPath, args, cwd, scanner);
     }
     async run(command, args, cwd, scanner) {
-        const spawnOptions = {};
+        const spawnOptions = {
+            stdio: ['inherit', 'pipe', 'pipe'],
+        };
         if (cwd) {
             spawnOptions.cwd = cwd;
         }
@@ -26,6 +28,10 @@ export class ProcessRunner {
                     scanner(line);
                 console.log(`> ${line}`);
             }
+            if (buffer.includes('Enter a value:')) {
+                console.log(buffer);
+                buffer = '';
+            }
         });
         let errorBuffer = '';
         child.stderr.on('data', (data) => {

package/dist/client/TerraformAdapter.js

@@ -40,15 +40,23 @@ export class TerraformAdapter {
             throw new KnownException('Can not find terraform files. Command needs to be run in a directory with terraform files');
         }
     }
-    async deploy(envAttrs, tfArgs, cwd, attemptNo = 1) {
-        const args = [
+    tfArgs(envAttrs, tfArgs) {
+        return [
             `-var=env=${envAttrs.env}`,
             `-var=owner=${envAttrs.owner}`,
             `-var=env_size=${envAttrs.size}`,
             `-var=env_type=${envAttrs.type}`,
             ...tfArgs
         ];
-        console.log('Running:', 'terraform apply -auto-approve', ...args);
+    }
+    async plan(envAttrs, tfArgs, cwd) {
+        const args = this.tfArgs(envAttrs, tfArgs);
+        console.log('Running: terraform plan -auto-approve', ...args);
+        await this.processRunner.run('terraform', ['plan', ...args], cwd);
+    }
+    async deploy(envAttrs, tfArgs, cwd, attemptNo = 1) {
+        const args = this.tfArgs(envAttrs, tfArgs);
+        console.log('Running: terraform apply -auto-approve', ...args);
         this.printTime();
         try {
             await this.processRunner.run('terraform', ['apply', '-auto-approve', ...args], cwd);

package/dist/commands/configure.js

@@ -0,0 +1,23 @@
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+import { configService } from '../container.js';
+import { wrap } from './utils.js';
+export function configure(program) {
+    program
+        .command('configure')
+        .description('Configure user settings on your local machine')
+        .action(wrap(handler));
+}
+async function handler() {
+    const answers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'owner',
+            message: 'owner is required to deploy any env\n'
+                + 'this value will be used as default - if not provided via --owner key in "deploy" command\n'
+                + '(prefer GitHub username)\n'
+                + 'owner:',
+        },
+    ]);
+    configService.saveConfig({ owner: answers.owner });
+}

package/dist/commands/delete.js

@@ -1,15 +1,26 @@
 import { Command } from 'commander';
-import { envCtl } from '../container.js';
+import { configService, envCtl } from '../container.js';
+import { KnownException } from '../exceptions.js';
 import { wrap } from './utils.js';
 export function deleteIt(program) {
     program
         .command('delete')
         .description('Delete a development environment')
-        .requiredOption('--env <env>', 'Environment name (can be git hash). {project}-{env} give env key used to store env state (s3 key in case of AWS)')
+        .option('--env <env>', 'Environment name (can be git hash). {project}-{env} give env key used to store env state (s3 key in case of AWS)')
         .option('--project <project>', 'Project code (like tt). Used when multiple projects deployed in same AWS account')
         .action(wrap(handler));
 }
 async function handler(options) {
     let { env, project } = options;
+    if (!env) {
+        const owner = configService.getOwner();
+        if (!owner) {
+            throw new KnownException('--env argument is not provided\n'
+                + 'default to owner from local configuration, but it is not configured\n'
+                + 'please call with --env argument or run \'envctl configure\' to configure owner');
+        }
+        console.log(`Env name not provided, default to owner name ${owner}`);
+        env = owner;
+    }
     await envCtl.delete(env, project);
 }

package/dist/commands/deploy.js

@@ -1,14 +1,18 @@
 import { Command } from 'commander';
-import { envCtl } from '../container.js';
-import { ensureKind, wrap } from './utils.js';
+import inquirer from 'inquirer';
+import { configService, envCtl } from '../container.js';
+import { KnownException } from '../exceptions.js';
+import { EnvType } from '../model/index.js';
+import { EnvSize } from '../model/index.js';
+import { ensureEnumValue, ensureKind, wrap } from './utils.js';
 export function deploy(program) {
     program
         .command('deploy')
         .description('Create new or update existing dev environment')
         .option('--project <project>', 'Project code (like tt). Used when multiple projects deployed in same AWS account')
         .option('--env <env>', 'Environment name (can be git hash). {project}-{env} give env key used to store env state (s3 key in case of AWS)')
-        .requiredOption('--owner <owner>', 'Environment owner (GH username)')
-        .requiredOption('--size <size>', 'Environment size: min, small, full')
+        .option('--owner <owner>', 'Environment owner (GH username)')
+        .option('--size <size>', 'Environment size: min, small, full')
         .option('--type <type>', 'Environment type: dev, prod', 'dev')
         .option('--kind <kind>', 'Environment kind: complete project (default) or some slice such as tt-core + tt-web')
         .option('--cwd <cwd>', 'Working directory (default: current directory)')
@@ -17,12 +21,39 @@ export function deploy(program) {
         .action(wrap(handler));
 }
 async function handler(tfArgs, options) {
+    const envDto = await parseEnvDto(options);
+    await envCtl.deploy(envDto, tfArgs, options.cwd);
+}
+export async function parseEnvDto(options) {
     let { project, env, owner, size, type, kind, cwd } = options;
+    if (!owner) {
+        owner = configService.getOwner();
+        if (!owner) {
+            throw new KnownException('when called without --owner option, first call \'envctl configure\'');
+        }
+        console.log(`Owner not provided, default to configured owner ${owner}`);
+    }
     if (!env) {
         console.log(`Env name not provided, default to owner name ${owner}`);
         env = owner;
     }
     kind = ensureKind(kind, cwd);
-    const envAttributes = { project, env, owner, size, type, kind };
-    await envCtl.deploy(envAttributes, tfArgs, options.cwd);
+    let envSize;
+    if (size) {
+        envSize = ensureEnumValue(EnvSize, size, 'size');
+    }
+    else {
+        const answer = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'size',
+                message: 'Environment size:',
+                choices: Object.values(EnvSize),
+                default: EnvSize.Small,
+            }
+        ]);
+        envSize = answer.size;
+    }
+    const envType = ensureEnumValue(EnvType, type, 'type');
+    return { project, env, owner, size: envSize, type: envType, kind };
 }

package/dist/commands/index.js

@@ -1,2 +1,4 @@
+export { configure } from './configure.js';
 export { deploy } from './deploy.js';
 export { deleteIt } from './delete.js';
+export { plan } from './plan.js';

package/dist/commands/plan.js

@@ -0,0 +1,22 @@
+import { Command } from 'commander';
+import { envCtl } from '../container.js';
+import { parseEnvDto } from './deploy.js';
+import { wrap } from './utils.js';
+export function plan(program) {
+    program
+        .command('plan')
+        .description('High level wrapper for terraform plan. Compliments deploy command: if you plan to deploy env with envctl deploy,'
+        + ' then it is recommended to do plan with envctl plan to guarantee consistent behavior')
+        .option('--env <env>', 'Environment name (can be git hash). {project}-{env} give env key used to store env state (s3 key in case of AWS)')
+        .option('--owner <owner>', 'Environment owner (GH username)')
+        .option('--size <size>', 'Environment size: min, small, full')
+        .option('--type <type>', 'Environment type: dev, prod', 'dev')
+        .option('--cwd <cwd>', 'Working directory (default: current directory)')
+        .allowUnknownOption(true)
+        .argument('[args...]')
+        .action(wrap(handler));
+}
+async function handler(tfArgs, options) {
+    const envDto = await parseEnvDto(options);
+    await envCtl.plan(envDto, tfArgs, options.cwd);
+}

package/dist/commands/utils.js

@@ -1,6 +1,6 @@
 import path from 'path';
-import { stdin as input, stdout as output } from 'process';
-import { createInterface } from 'readline/promises';
+import { ExitPromptError } from '@inquirer/core';
+import inquirer from 'inquirer';
 import { BusinessException, ExitException, KnownException } from '../exceptions.js';
 export function wrap(callable) {
     return async (...args) => {
@@ -12,7 +12,9 @@ export function wrap(callable) {
             if (error instanceof KnownException || error instanceof BusinessException) {
                 console.error(error.message);
             }
-            else if (!(error instanceof ExitException)) {
+            else if (error instanceof ExitException || error instanceof ExitPromptError) {
+            }
+            else {
                 console.error('Unknown error:', error);
             }
             process.exit(1);
@@ -22,16 +24,17 @@ export function wrap(callable) {
         }
     };
 }
-export async function prompt(question) {
-    const rl = createInterface({ input, output });
-    const answer = await rl.question(question);
-    rl.close();
+export async function promptYesNo(message, defaultValue = false) {
+    const { answer } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'answer',
+            message,
+            default: defaultValue,
+        },
+    ]);
     return answer;
 }
-export async function promptYesNo(question) {
-    const answer = await prompt(question);
-    return answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes';
-}
 export function ensureKind(kind, cwd) {
     if (kind) {
         return kind;
@@ -53,3 +56,10 @@ function resolveCwd(cwd) {
     }
     return path.resolve(process.cwd(), cwd);
 }
+export function ensureEnumValue(enumObj, value, name) {
+    const values = Object.values(enumObj);
+    if (!values.includes(value)) {
+        throw new KnownException(`Invalid ${name}: "${value}". Must be one of: ${values.join(', ')}`);
+    }
+    return value;
+}

package/dist/container.js

@@ -1,9 +1,10 @@
 import { EnvApiClient, HttpClient, TerraformAdapter } from './client/index.js';
 import { ProcessRunner } from './client/ProcessRunner.js';
-import { EnvCtl } from './service/index.js';
+import { ConfigService, EnvCtl } from './service/index.js';
+const configService = new ConfigService();
 const httpClient = new HttpClient();
 const envApiClient = new EnvApiClient(httpClient);
 const processRunner = new ProcessRunner();
 const terraformAdapter = new TerraformAdapter(processRunner);
 const envCtl = new EnvCtl(envApiClient, terraformAdapter);
-export { envCtl };
+export { configService, envCtl };

package/dist/index.js

@@ -2,7 +2,7 @@
 import { createRequire } from 'module';
 import { Command } from 'commander';
 import updateNotifier from 'update-notifier';
-import { deleteIt, deploy } from './commands/index.js';
+import { configure, deleteIt, deploy, plan } from './commands/index.js';
 const require = createRequire(import.meta.url);
 const pkg = require('../package.json');
 updateNotifier({ pkg, updateCheckInterval: 0 }).notify();
@@ -11,6 +11,8 @@ program
     .name('envctl')
     .description('CLI to manage environments')
     .version(pkg.version);
+configure(program);
 deploy(program);
 deleteIt(program);
+plan(program);
 program.parse(process.argv);

package/dist/model/EnvSize.js

@@ -0,0 +1,11 @@
+export var EnvSize;
+(function (EnvSize) {
+    EnvSize["Min"] = "min";
+    EnvSize["Small"] = "small";
+    EnvSize["Full"] = "full";
+})(EnvSize || (EnvSize = {}));
+export const EnvSizeAvgTime = {
+    [EnvSize.Min]: 2,
+    [EnvSize.Small]: 5,
+    [EnvSize.Full]: 10,
+};

package/dist/model/EnvStatus.js

@@ -0,0 +1,7 @@
+export var EnvStatus;
+(function (EnvStatus) {
+    EnvStatus["Creating"] = "CREATING";
+    EnvStatus["Active"] = "ACTIVE";
+    EnvStatus["Updating"] = "UPDATING";
+    EnvStatus["Deleting"] = "DELETING";
+})(EnvStatus || (EnvStatus = {}));

package/dist/model/EnvType.js

@@ -0,0 +1,5 @@
+export var EnvType;
+(function (EnvType) {
+    EnvType["Dev"] = "dev";
+    EnvType["Prod"] = "prod";
+})(EnvType || (EnvType = {}));

package/dist/model/index.js

@@ -1 +1,4 @@
-export {};
+export { EnvSize } from './EnvSize.js';
+export { EnvSizeAvgTime } from './EnvSize.js';
+export { EnvStatus } from './EnvStatus.js';
+export { EnvType } from './EnvType.js';

package/dist/service/ConfigService.js

@@ -0,0 +1,28 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import path from 'path';
+const CONFIG_PATH = path.join(os.homedir(), '.envctl', 'config.json');
+export class ConfigService {
+    config;
+    constructor() {
+    }
+    saveConfig(config) {
+        const mergedConfig = { ...this.loadConfig(), ...config };
+        const data = JSON.stringify(mergedConfig, null, 2);
+        fs.mkdirSync(path.dirname(CONFIG_PATH), { recursive: true });
+        fs.writeFileSync(CONFIG_PATH, data);
+    }
+    loadConfig() {
+        if (this.config)
+            return this.config;
+        this.config = {};
+        if (fs.existsSync(CONFIG_PATH)) {
+            const data = fs.readFileSync(CONFIG_PATH, 'utf-8');
+            this.config = JSON.parse(data);
+        }
+        return this.config;
+    }
+    getOwner() {
+        return this.loadConfig()?.owner;
+    }
+}

package/dist/service/EnvCtl.js

@@ -1,5 +1,6 @@
 import { promptYesNo } from '../commands/utils.js';
 import { KnownException } from '../exceptions.js';
+import { EnvSizeAvgTime, EnvStatus } from '../model/index.js';
 export class EnvCtl {
     envApi;
     terraformAdapter;
@@ -7,8 +8,15 @@ export class EnvCtl {
         this.envApi = envApi;
         this.terraformAdapter = terraformAdapter;
     }
+    key(project, env) {
+        return project ? `${project}-${env}` : env;
+    }
+    async plan(envDto, tfArgs, cwd) {
+        console.log('Deploying resources');
+        await this.terraformAdapter.plan(envDto, tfArgs, cwd);
+    }
     async deploy(envDto, tfArgs, cwd) {
-        const key = envDto.project ? `${envDto.project}-${envDto.env}` : envDto.env;
+        const key = this.key(envDto.project, envDto.env);
         console.log(`Check if env ${key} already exists`);
         const env = await this.envApi.get(key);
         if (env === null) {
@@ -36,31 +44,33 @@ export class EnvCtl {
         if (env.kind !== envDto.kind) {
             throw new KnownException(`Can not change env kind ${env.kind} -> ${envDto.kind}`);
         }
-        if (env.status === 'CREATING') {
-            const answerYes = await promptYesNo('Env status is CREATING, likely to error in previous run\nDo you want to proceed with deployment? (y/n) ');
-            if (answerYes) {
-                await this.runDeploy(key, envDto, tfArgs, cwd);
+        switch (env.status) {
+            case EnvStatus.Creating:
+            case EnvStatus.Updating: {
+                const answerYes = await promptYesNo(`Env status is ${env.status}, likely to be an error from a previous run\n`
+                    + 'Do you want to proceed with deployment?');
+                if (answerYes) {
+                    await this.runDeploy(key, envDto, tfArgs, cwd);
+                }
+                break;
             }
-        }
-        else if (env.status === 'UPDATING') {
-            const answerYes = await promptYesNo('Env status is UPDATING, likely to error in previous run\nDo you want to proceed with deployment? (y/n) ');
-            if (answerYes) {
+            case EnvStatus.Active: {
+                console.log('Env status is ACTIVE\nWill lock for update and run terraform apply (to update resources)');
+                await this.envApi.lockForUpdate(key);
                 await this.runDeploy(key, envDto, tfArgs, cwd);
+                break;
             }
-        }
-        else if (env.status === 'ACTIVE') {
-            console.log('Env status is ACTIVE\nWill lock for update and run terraform apply (to update resources)');
-            await this.envApi.lockForUpdate(key);
-            await this.runDeploy(key, envDto, tfArgs, cwd);
-        }
-        else if (env.status === 'DELETING') {
-            const time = env.size === 'min' ? 2 : 5;
-            throw new KnownException(`Env status is DELETING, please wait (~${time} min)`);
+            case EnvStatus.Deleting: {
+                const time = EnvSizeAvgTime[env.size];
+                throw new KnownException(`Env status is DELETING, please wait (~${time} min)`);
+            }
+            default:
+                throw new KnownException(`Unsupported environment status: ${env.status}`);
         }
     }
-    async runDeploy(key, envAttrs, tfArgs, cwd) {
+    async runDeploy(key, envDto, tfArgs, cwd) {
         console.log('Deploying resources');
-        await this.terraformAdapter.deploy(envAttrs, tfArgs, cwd);
+        await this.terraformAdapter.deploy(envDto, tfArgs, cwd);
         console.log('Activating env (to finish creation)');
         await this.envApi.activate(key);
         console.log('Lock env to run db evolution');
@@ -69,14 +79,14 @@ export class EnvCtl {
         await this.envApi.activate(key);
     }
     async delete(envName, project) {
-        const key = project ? `${project}-${envName}` : envName;
+        const key = this.key(project, envName);
         console.log(`Retrieve env`);
         const env = await this.envApi.get(key);
         if (env === null) {
             throw new KnownException(`Environment ${key} does not exist`);
         }
-        if (env.status === 'CREATING') {
-            const answerYes = await promptYesNo('Environment is still being created.\nDo you want to delete it? (y/n) ');
+        if (env.status === EnvStatus.Creating) {
+            const answerYes = await promptYesNo('Environment is still being created.\nDo you want to delete it?');
             if (!answerYes) {
                 throw new KnownException('Aborting env deletion');
             }

package/dist/service/index.js

@@ -1 +1,2 @@
 export { EnvCtl } from './EnvCtl.js';
+export { ConfigService } from './ConfigService.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agilecustoms/envctl",
   "description": "node.js CLI client for manage environments",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "author": "Alex Chekulaev",
   "type": "module",
   "bin": {
@@ -26,14 +26,17 @@
     "build": "tsc",
     "run": "node dist/index.js",
     "run-version": "tsc --sourceMap true && npm run run -- --version",
-    "run-deploy": "tsc --sourceMap true && npm run run -- deploy --owner laxa1986 --size min --cwd ../tt-core",
-    "run-delete": "tsc --sourceMap true && npm run run -- delete --env laxa1986"
+    "run-configure": "tsc --sourceMap true && npm run run -- configure",
+    "run-plan": "tsc --sourceMap true && npm run run -- plan --size min --cwd ../tt-core",
+    "run-deploy": "tsc --sourceMap true && npm run run -- deploy --size min --cwd ../tt-core",
+    "run-delete": "tsc --sourceMap true && npm run run -- delete"
   },
   "dependencies": {
     "@aws-sdk/client-sts": "^3.716.0",
     "@aws-sdk/credential-providers": "^3.716.0",
     "aws4": "^1.13.2",
     "commander": "^13.0.0",
+    "inquirer": "^12.6.0",
     "update-notifier": "^7.3.1"
   },
   "devDependencies": {