@agilecustoms/envctl 0.20.1 → 0.21.0

package/README.md

@@ -4,8 +4,7 @@
 
 ## usage
 ```shell
-envctl deploy --key tt-alexc --owner laxa1986 --size min --type dev \
-    -var-file=versions.tfvars -var="env=tt-alex" -var="log_level=debug"
+envctl deploy --env alexc -var-file=versions.tfvars -var="env=alexc" -var="log_level=debug"
 ```
 
 ## setup/update

package/dist/client/CliHelper.js

@@ -1,11 +1,7 @@
 import path from 'path';
 import inquirer from 'inquirer';
 import { KnownException } from '../exceptions.js';
-import { EnvSize, EnvType } from '../model/index.js';
 import { ConfigService } from '../service/index.js';
-function isRunFromIdeaMakePlugin() {
-    return !!process.env['XPC_SERVICE_NAME']?.includes('jetbrains');
-}
 export class CliHelper {
     configService;
     constructor(configService) {
@@ -51,49 +47,6 @@ export class CliHelper {
         console.log(`Inferred kind from directory name: ${kind}`);
         return kind;
     }
-    async parseEnvInput(input, envName, owner, cwd) {
-        owner = this.ensureOwner(owner);
-        const { size } = input;
-        let { type, kind } = input;
-        kind = this.ensureKind(kind, cwd);
-        let envSize;
-        if (size) {
-            envSize = ensureEnumValue(EnvSize, size, 'size');
-        }
-        else {
-            const answer = await inquirer.prompt([
-                isRunFromIdeaMakePlugin()
-                    ? {
-                        type: 'input',
-                        name: 'size',
-                        message: `Environment size [${Object.values(EnvSize).join(', ')}]:`,
-                        default: EnvSize.Small,
-                        validate: input => Object.values(EnvSize).includes(input.trim()) ? true : 'Invalid size'
-                    }
-                    : {
-                        type: 'list',
-                        name: 'size',
-                        message: 'Environment size:',
-                        choices: Object.values(EnvSize),
-                        default: EnvSize.Small,
-                    }
-            ]);
-            envSize = answer.size;
-        }
-        if (!type) {
-            type = EnvType.Dev;
-            console.log(`Default environment type: ${EnvType.Dev}`);
-        }
-        const envType = ensureEnumValue(EnvType, type || EnvType.Dev, 'type');
-        return {
-            project: input.project,
-            env: envName,
-            owner,
-            size: envSize,
-            type: envType,
-            kind
-        };
-    }
 }
 function getDirName(cwd) {
     cwd = resolveCwd(cwd);
@@ -108,10 +61,3 @@ function resolveCwd(cwd) {
     }
     return path.resolve(process.cwd(), cwd);
 }
-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/client/EnvApiClient.js

@@ -19,24 +19,18 @@ export class EnvApiClient {
     }
     async createEphemeral(env) {
         const res = await this.httpClient.post('/ci/env-ephemeral', env);
-        const token = res.token;
-        return { ...env, token, ephemeral: true, status: EnvStatus.Init };
+        return res.token;
     }
     async create(env) {
-        const res = await this.httpClient.post('/ci/env', env);
-        const token = res.token;
-        return { ...env, token, ephemeral: false, status: EnvStatus.Deploying };
+        await this.httpClient.post('/ci/env', env);
+        return { ...env, ephemeral: false, status: EnvStatus.Deploying };
     }
     async activate(env) {
-        await this.httpClient.fetch(`/ci/env/${env.key}/activate`, {
-            method: 'POST'
-        });
+        await this.httpClient.post(`/ci/env/${env.key}/activate`);
         env.status = EnvStatus.Active;
     }
     async lockForUpdate(env) {
-        const res = await this.httpClient.fetch(`/ci/env/${env.key}/lock-for-update`, {
-            method: 'POST'
-        });
+        const res = await this.httpClient.post(`/ci/env/${env.key}/lock-for-update`);
         env.status = res.status;
     }
     async delete(env) {
@@ -55,4 +49,8 @@ export class EnvApiClient {
         env.status = EnvStatus.Deleting;
         return result.statusText;
     }
+    async setVars(env, vars) {
+        await this.httpClient.post(`/ci/env/${env.key}/vars`, vars);
+        env.vars = { ...env.vars || {}, ...vars };
+    }
 }

package/dist/client/HttpClient.js

@@ -7,14 +7,16 @@ export class HttpClient {
         this.awsCredsHelper = awsCredsHelper;
     }
     async post(path, body, options = {}) {
-        return await this.fetch(path, {
-            method: 'POST',
-            body: JSON.stringify(body),
-            headers: {
-                'Content-Type': 'application/json'
-            },
-            ...options
-        });
+        options.method = 'POST';
+        if (body) {
+            options.body = JSON.stringify(body);
+            const headers = options.headers || {};
+            if (!headers['Content-Type']) {
+                headers['Content-Type'] = 'application/json';
+            }
+            options.headers = headers;
+        }
+        return await this.fetch(path, options);
     }
     async fetch(path, options = {}) {
         const awsCreds = await this.awsCredsHelper.getCredentials();
@@ -53,6 +55,6 @@ export class HttpClient {
         if (response.status === 422) {
             throw new BusinessException(message);
         }
-        throw new HttpException(response.status, await response.text());
+        throw new HttpException(response.status, message);
     }
 }

package/dist/client/ProcessRunner.js

@@ -1,16 +1,17 @@
 import { spawn } from 'child_process';
 import path from 'path';
+import * as readline from 'readline';
 import { fileURLToPath } from 'url';
 import { ProcessException } from '../exceptions.js';
 export class ProcessRunner {
     async runScript(script, args, cwd, scanner) {
         const __dirname = path.dirname(fileURLToPath(import.meta.url));
         const scriptPath = path.join(__dirname, `../../scripts/${script}`);
-        return this.run(scriptPath, args, cwd, scanner);
+        await this.run(scriptPath, args, cwd, scanner);
     }
-    async run(command, args, cwd, scanner) {
+    async run(command, args, cwd, out_scanner, in_scanner) {
         const spawnOptions = {
-            stdio: ['inherit', 'pipe', 'pipe'],
+            stdio: ['pipe', 'pipe', 'pipe'],
         };
         if (cwd) {
             spawnOptions.cwd = cwd;
@@ -18,9 +19,22 @@ export class ProcessRunner {
         const child = spawn(command, args, spawnOptions);
         child.stdout.setEncoding('utf8');
         child.stderr.setEncoding('utf8');
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.on('line', (line) => {
+            if (in_scanner) {
+                in_scanner(line);
+            }
+            child.stdin.write(line + '\n');
+        });
+        rl.on('SIGINT', () => {
+            child.kill('SIGINT');
+        });
         function processLine(line) {
-            if (scanner)
-                scanner(line);
+            if (out_scanner)
+                out_scanner(line);
             console.log(line);
         }
         let buffer = '';
@@ -30,7 +44,7 @@ export class ProcessRunner {
             buffer = lines.pop() || '';
             lines.forEach(processLine);
             if (buffer.includes('Enter a value:')) {
-                console.log(buffer);
+                processLine(buffer);
                 buffer = '';
             }
         });
@@ -40,6 +54,7 @@ export class ProcessRunner {
         });
         return new Promise((resolve, reject) => {
             child.on('close', (code) => {
+                rl.close();
                 processLine(buffer);
                 if (code === 0) {
                     if (errorBuffer) {

package/dist/client/TerraformAdapter.js

@@ -1,3 +1,6 @@
+import fs from 'fs';
+import path from 'path';
+import { glob } from 'glob';
 import { AbortedException, KnownException, ProcessException, TerraformInitRequired } from '../exceptions.js';
 const MAX_ATTEMPTS = 2;
 const RETRYABLE_ERRORS = [
@@ -42,18 +45,83 @@ export class TerraformAdapter {
             throw new KnownException('Can not find terraform files. Command needs to be run in a directory with terraform files');
         }
     }
-    tfArgs(env, tfArgs) {
-        return [
-            `-var=env=${env.env}`,
-            `-var=owner=${env.owner}`,
-            `-var=env_size=${env.size}`,
-            `-var=env_type=${env.type}`,
-            `-var=ephemeral=${env.ephemeral}`,
-            ...tfArgs
-        ];
+    tfArgs(env, cwd) {
+        const varDefs = this.getVarDefs(cwd);
+        const argVars = this.getArgVars(env.args);
+        const specialFields = { ...env, env: env.envName };
+        const extraArgs = [];
+        for (const name of ['env', 'owner', 'ephemeral']) {
+            if (varDefs[name] && !argVars[name]) {
+                extraArgs.push('-var=' + name + '=' + specialFields[name]);
+            }
+        }
+        Object.entries(env.vars || {}).forEach(([key, value]) => {
+            if (varDefs[key] && !argVars[key]) {
+                extraArgs.push('-var=' + key + '=' + value);
+            }
+        });
+        return [...extraArgs, ...env.args];
+    }
+    getVarDefs(cwd) {
+        const dir = cwd ?? process.cwd();
+        const tfFiles = glob.sync(path.join(dir, '*.tf'));
+        const results = {};
+        const varBlockRegex = /variable\s+"(\w+)"\s*{([^}]+)}/g;
+        const defaultRegex = /\n[^#\n]*default\s+=\s+/;
+        const sensitiveRegex = /\n[^#\n]*sensitive\s+=\s+true/;
+        for (const file of tfFiles) {
+            const content = fs.readFileSync(file, 'utf8');
+            let match;
+            while ((match = varBlockRegex.exec(content)) !== null) {
+                const varName = match[1];
+                const varBody = match[2];
+                results[varName] = {
+                    name: varName,
+                    default: defaultRegex.test(varBody),
+                    sensitive: sensitiveRegex.test(varBody),
+                };
+            }
+        }
+        return results;
+    }
+    getArgVars(tfArgs) {
+        const result = {};
+        tfArgs
+            .filter(arg => arg.startsWith('-var='))
+            .forEach((arg) => {
+            const keyValue = arg.slice(5);
+            const eqIndex = keyValue.indexOf('=');
+            if (eqIndex === -1) {
+                console.log('terraform var argument is not in key=value format:', arg);
+                return;
+            }
+            const key = keyValue.slice(0, eqIndex);
+            result[key] = keyValue.slice(eqIndex + 1);
+        });
+        return result;
     }
-    async plan(env, tfArgs, cwd, attemptNo = 1) {
-        const args = this.tfArgs(env, tfArgs);
+    getNewVars(envTerraform, onDemandVars, cwd) {
+        const varDefs = this.getVarDefs(cwd);
+        const argVars = this.getArgVars(envTerraform.args);
+        const envVars = envTerraform.vars;
+        const vars = { ...argVars, ...onDemandVars };
+        const newVars = {};
+        Object.entries(vars).forEach(([key, value]) => {
+            const varDef = varDefs[key];
+            if (!varDef) {
+                console.warn(`Terraform variable ${key} passed, but not found in .tf files`);
+                return;
+            }
+            if (varDef.sensitive)
+                return;
+            if (!envVars || !envVars[key]) {
+                newVars[key] = value;
+            }
+        });
+        return newVars;
+    }
+    async plan(env, cwd, attemptNo = 1) {
+        const args = this.tfArgs(env, cwd);
         console.log('Running: terraform plan -auto-approve', ...args, '\n');
         try {
             await this.processRunner.run('terraform', ['plan', ...args], cwd);
@@ -64,23 +132,41 @@ export class TerraformAdapter {
             }
             if (attemptNo < MAX_ATTEMPTS && RETRYABLE_ERRORS.some(err => error.message.includes(err))) {
                 console.warn(`Retrying terraform plan due to error: ${error.message}`);
-                return this.plan(env, tfArgs, cwd, attemptNo + 1);
+                return this.plan(env, cwd, attemptNo + 1);
             }
             const lockId = this.lockId(error, attemptNo);
             if (lockId) {
                 await this.promptUnlock(lockId, cwd);
                 console.info('State unlocked, retrying terraform plan');
-                return this.plan(env, tfArgs, cwd, attemptNo + 1);
+                return this.plan(env, cwd, attemptNo + 1);
             }
             throw new KnownException(`terraform plan failed with code ${error.code}:\n${error.message}`, { cause: error });
         }
     }
-    async apply(env, tfArgs, cwd, attemptNo = 1) {
-        const args = this.tfArgs(env, tfArgs);
+    async apply(env, onDemandVars, cwd, attemptNo = 1) {
+        let inputTfVariable = false;
+        let tfVarName = '';
+        function out_scanner(line) {
+            inputTfVariable = false;
+            const match = line.match(/var\.([a-zA-Z_0-9]+)/);
+            if (match) {
+                tfVarName = match[1];
+            }
+            else if (line.includes('Enter a value:')) {
+                inputTfVariable = true;
+            }
+        }
+        function in_scanner(line) {
+            if (inputTfVariable && tfVarName) {
+                onDemandVars[tfVarName] = line;
+                tfVarName = '';
+            }
+        }
+        const args = this.tfArgs(env, cwd);
         console.log('Running: terraform apply -auto-approve', ...args, '\n');
         this.printTime();
         try {
-            await this.processRunner.run('terraform', ['apply', '-auto-approve', ...args], cwd);
+            await this.processRunner.run('terraform', ['apply', '-auto-approve', ...args], cwd, out_scanner, in_scanner);
             this.printTime();
         }
         catch (error) {
@@ -92,25 +178,25 @@ export class TerraformAdapter {
             }
             if (attemptNo < MAX_ATTEMPTS && RETRYABLE_ERRORS.some(err => error.message.includes(err))) {
                 console.warn(`Retrying terraform apply due to error: ${error.message}`);
-                return this.apply(env, tfArgs, cwd, attemptNo + 1);
+                return this.apply(env, onDemandVars, cwd, attemptNo + 1);
             }
             const lockId = this.lockId(error, attemptNo);
             if (lockId) {
                 await this.promptUnlock(lockId, cwd);
                 console.info('State unlocked, retrying terraform apply');
-                return this.apply(env, tfArgs, cwd, attemptNo + 1);
+                return this.apply(env, onDemandVars, cwd, attemptNo + 1);
             }
             throw new KnownException(`terraform apply failed with code ${error.code}:\n${error.message}`, { cause: error });
         }
     }
-    async destroy(env, tfArgs, force, cwd, attemptNo = 1) {
+    async destroy(env, force, cwd, attemptNo = 1) {
         let wrongDir = false;
         const scanner = (line) => {
             if (line.includes('Either you have not created any objects yet or the existing objects were')) {
                 wrongDir = true;
             }
         };
-        const args = this.tfArgs(env, tfArgs);
+        const args = this.tfArgs(env, cwd);
         console.log('Running: terraform destroy -auto-approve', ...args, '\n');
         try {
             await this.processRunner.run('terraform', ['destroy', '-auto-approve', ...args], cwd, scanner);
@@ -128,7 +214,7 @@ export class TerraformAdapter {
                     await this.promptUnlock(lockId, cwd);
                 }
                 console.info('State unlocked, retrying terraform destroy');
-                return this.destroy(env, tfArgs, force, cwd, attemptNo + 1);
+                return this.destroy(env, force, cwd, attemptNo + 1);
             }
             throw new KnownException(`terraform destroy failed with code ${error.code}:\n${error.message}`, { cause: error });
         }

package/dist/commands/_keys.js

@@ -4,7 +4,5 @@ export const _keys = {
     FORCE: 'Force deletion without confirmation',
     KIND: 'Environment kind: complete project (default) or some slice such as tt-core + tt-web',
     OWNER: 'Environment owner (GH username)',
-    PROJECT: 'Project code (like tt). Used when multiple projects deployed in same AWS account',
-    SIZE: 'Environment size: min, small, full',
-    TYPE: 'Environment type: dev, prod',
+    PROJECT: 'Project code (like tt). Used when multiple projects deployed in same AWS account'
 };

package/dist/commands/createEphemeral.js

@@ -9,12 +9,10 @@ export function createEphemeral(program) {
         .option('--project <project>', _keys.PROJECT)
         .requiredOption('--env <env>', _keys.ENV)
         .option('--owner <owner>', _keys.OWNER)
-        .requiredOption('--size <size>', _keys.SIZE)
-        .requiredOption('--type <type>', _keys.TYPE)
         .action(wrap(handler));
 }
 async function handler(options) {
-    const { project, env, owner, size, type } = options;
-    const token = await envCtl.createEphemeral(project, env, owner, size, type);
+    const { project, env, owner } = options;
+    const token = await envCtl.createEphemeral(project, env, owner);
     console.log(token);
 }

package/dist/commands/deploy.js

@@ -9,8 +9,6 @@ export function deploy(program) {
         .option('--project <project>', _keys.PROJECT)
         .option('--env <env>', _keys.ENV)
         .option('--owner <owner>', _keys.OWNER)
-        .option('--size <size>', _keys.SIZE)
-        .option('--type <type>', _keys.TYPE)
         .option('--kind <kind>', _keys.KIND)
         .option('--cwd <cwd>', _keys.CWD)
         .allowUnknownOption(true)
@@ -19,6 +17,7 @@ export function deploy(program) {
 }
 async function handler(tfArgs, options) {
     await awsCredsHelper.ensureCredentials();
-    const { cwd, ...envDto } = options;
+    const { cwd, env, ...envDto } = options;
+    envDto.envName = env;
     await envCtl.deploy(envDto, tfArgs, cwd);
 }

package/dist/commands/plan.js

@@ -10,8 +10,6 @@ export function plan(program) {
         .option('--project <project>', _keys.PROJECT)
         .option('--env <env>', _keys.ENV)
         .option('--owner <owner>', _keys.OWNER)
-        .option('--size <size>', _keys.SIZE)
-        .option('--type <type>', _keys.TYPE)
         .option('--cwd <cwd>', _keys.CWD)
         .allowUnknownOption(true)
         .argument('[args...]')
@@ -19,6 +17,7 @@ export function plan(program) {
 }
 async function handler(tfArgs, options) {
     await awsCredsHelper.ensureCredentials();
-    const { cwd, ...envDto } = options;
+    const { cwd, env, ...envDto } = options;
+    envDto.envName = env;
     await envCtl.plan(envDto, tfArgs, cwd);
 }

package/dist/model/index.js

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

package/dist/service/EnvCtl.js

@@ -1,5 +1,5 @@
 import { KnownException, TerraformInitRequired } from '../exceptions.js';
-import { EnvSize, EnvSizeAvgTime, EnvStatus, EnvType } from '../model/index.js';
+import { EnvStatus, } from '../model/index.js';
 export class EnvCtl {
     cliHelper;
     envApi;
@@ -27,7 +27,7 @@ export class EnvCtl {
         }
     }
     async tryGetEnv(input) {
-        let envName = input.env;
+        let envName = input.envName;
         let owner = input.owner;
         if (!envName) {
             owner = this.cliHelper.ensureOwner(owner);
@@ -43,18 +43,12 @@ export class EnvCtl {
         else {
             console.log(`Env ${key} does not exist`);
         }
-        return { envName, owner, key, env };
+        return { envName, anOwner: owner, key, env };
     }
     checkInput(env, input, cwd) {
         if (input.owner && env.owner !== input.owner) {
             throw new KnownException(`Can not change env owner ${env.owner} -> ${input.owner}`);
         }
-        if (input.size && env.size !== input.size) {
-            throw new KnownException(`Can not change env size ${env.size} -> ${input.size}`);
-        }
-        if (input.type && env.type !== input.type) {
-            throw new KnownException(`Can not change env type ${env.type} -> ${input.type}`);
-        }
         const kind = this.cliHelper.ensureKind(input.kind, cwd);
         if ((input.kind || env.kind) && kind !== env.kind) {
             throw new KnownException(`Can not change env kind ${env.kind} -> ${kind}`);
@@ -65,8 +59,7 @@ export class EnvCtl {
             return;
         }
         if (env.status === EnvStatus.Deleting) {
-            const time = EnvSizeAvgTime[env.size];
-            throw new KnownException(`Env ${env.key} status is DELETING, please wait (~${time} min)`);
+            throw new KnownException(`Env ${env.key} status is DELETING, please wait`);
         }
         throw new KnownException(`Env ${env.key} status is ${env.status}, can not run this command`);
     }
@@ -75,41 +68,40 @@ export class EnvCtl {
         await this.terraformAdapter.init(key, cwd);
     }
     async plan(input, tfArgs, cwd) {
-        const { envName, owner, key, env } = await this.tryGetEnv(input);
+        const { envName, anOwner, key, env } = await this.tryGetEnv(input);
         if (env == null) {
-            const envInput = await this.cliHelper.parseEnvInput(input, envName, owner, cwd);
-            const envTerraform = { ...envInput, ephemeral: false };
+            const owner = this.cliHelper.ensureOwner(anOwner);
             await this.terraformAdapter.init(key, cwd);
-            await this.terraformAdapter.plan(envTerraform, tfArgs, cwd);
+            const envTerraform = { envName, ephemeral: false, owner, args: tfArgs };
+            await this.terraformAdapter.plan(envTerraform, cwd);
             return;
         }
         this.checkInput(env, input, cwd);
-        const envOwner = env.owner;
-        const envTerraform = { ...env, env: envName, owner: envOwner, ephemeral: false };
+        const owner = env.owner;
         this.checkStatus(env);
         await this.promptUnlock(env);
         if (env.status !== EnvStatus.Active) {
             throw new KnownException(`Env ${env.key} status is ${env.status}, can not run plan`);
         }
-        await this.terraformAdapter.plan(envTerraform, tfArgs, cwd);
+        const envTerraform = { envName, ephemeral: false, owner, args: tfArgs, vars: env.vars };
+        await this.terraformAdapter.plan(envTerraform, cwd);
     }
-    async createEphemeral(project, envName, owner, size, type) {
+    async createEphemeral(project, envName, owner) {
         const key = this.key(project, envName);
         const env = await this.envApi.get(key);
         if (env !== null) {
             throw new KnownException(`Env ${key} already exists`);
         }
-        const createEnv = { key, owner, size, type };
-        const newEnv = await this.envApi.createEphemeral(createEnv);
-        return newEnv.token;
+        const createEnv = { key, owner };
+        return await this.envApi.createEphemeral(createEnv);
     }
     async deploy(input, tfArgs, cwd) {
-        const { envName, owner, key, env } = await this.tryGetEnv(input);
+        const { envName, anOwner, key, env } = await this.tryGetEnv(input);
         if (env === null) {
-            const envInput = await this.cliHelper.parseEnvInput(input, envName, owner, cwd);
+            const owner = this.cliHelper.ensureOwner(anOwner);
+            const kind = this.cliHelper.ensureKind(input.kind, cwd);
             console.log('Creating env tracking record in DynamoDB');
-            const { size, type, kind } = envInput;
-            const createEnv = { key, owner: envInput.owner, size, type, kind };
+            const createEnv = { key, owner, kind };
             const newEnv = await this.envApi.create(createEnv);
             return await this.runDeploy(newEnv, envName, tfArgs, cwd);
         }
@@ -119,8 +111,8 @@ export class EnvCtl {
             await this.envApi.lockForUpdate(env);
         }
         else if (env.status == EnvStatus.Updating) {
-            const answerYes = await this.cliHelper.promptYesNo(`Env status is ${env.status}, likely to be an error from a previous run\n`
-                + 'Do you want to proceed with deployment?');
+            const answerYes = await this.cliHelper.promptYesNo(`Env status is ${env.status},
+       likely to be an error from a previous run\nDo you want to proceed with deployment?`);
             if (!answerYes) {
                 console.log('Aborting deployment');
                 return;
@@ -134,20 +126,27 @@ export class EnvCtl {
     }
     async runDeploy(env, envName, tfArgs, cwd) {
         console.log('Deploying resources');
-        const { owner, size, type, ephemeral } = env;
-        const envTf = { owner: owner || 'system', size, type, ephemeral, env: envName };
+        const { ephemeral, vars } = env;
+        const envTerraform = { envName, ephemeral, owner: env.owner || 'system', args: tfArgs, vars };
+        const onDemandVars = {};
         try {
-            await this.terraformAdapter.apply(envTf, tfArgs, cwd);
+            await this.terraformAdapter.apply(envTerraform, onDemandVars, cwd);
         }
         catch (error) {
             if (error instanceof TerraformInitRequired) {
                 await this.terraformAdapter.init(env.key, cwd);
-                await this.terraformAdapter.apply(envTf, tfArgs, cwd);
+                await this.terraformAdapter.apply(envTerraform, onDemandVars, cwd);
             }
             else {
                 throw error;
             }
         }
+        finally {
+            const newVars = this.terraformAdapter.getNewVars(envTerraform, onDemandVars, cwd);
+            if (Object.keys(newVars).length) {
+                await this.envApi.setVars(env, newVars);
+            }
+        }
         console.log('Activating env (to finish creation)');
         await this.envApi.activate(env);
     }
@@ -207,10 +206,10 @@ export class EnvCtl {
             console.log('Lock env to run destroy');
             await this.envApi.lockForUpdate(env);
         }
-        const { owner, size, type, ephemeral } = env;
-        const tfEnv = { owner: owner || 'system', size, type, ephemeral, env: envName };
+        const { ephemeral, owner, vars } = env;
+        const envTerraform = { envName, ephemeral, owner: owner || 'system', args: tfArgs, vars };
         console.log('Destroying env resources');
-        await this.terraformAdapter.destroy(tfEnv, tfArgs, force, cwd);
+        await this.terraformAdapter.destroy(envTerraform, force, cwd);
         console.log('Unlock env');
         await this.envApi.activate(env);
         console.log(`Schedule env ${env.key} metadata deletion`);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agilecustoms/envctl",
   "description": "node.js CLI client for manage environments",
-  "version": "0.20.1",
+  "version": "0.21.0",
   "author": "Alex Chekulaev",
   "type": "module",
   "bin": {
@@ -28,8 +28,8 @@
     "run-version": "    tsc --sourceMap true && npm run run -- --version",
     "run-configure": "  tsc --sourceMap true && npm run run -- configure",
     "run-status": "     tsc --sourceMap true && npm run run -- status  --cwd ../tt-core",
-    "run-plan": "       tsc --sourceMap true && npm run run -- plan    --cwd ../tt-core --size min",
-    "run-deploy": "     tsc --sourceMap true && npm run run -- deploy  --cwd ../tt-core --size min",
+    "run-plan": "       tsc --sourceMap true && npm run run -- plan    --cwd ../tt-core",
+    "run-deploy": "     tsc --sourceMap true && npm run run -- deploy  --cwd ../tt-core -var=\"env_size=min\"",
     "run-delete": "     tsc --sourceMap true && npm run run -- delete  --cwd ../tt-core",
     "run-destroy": "    tsc --sourceMap true && npm run run -- destroy --cwd ../tt-core",
     "-": "",

package/dist/model/EnvSize.js

@@ -1,11 +0,0 @@
-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/EnvType.js

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