@agilecustoms/envctl 1.6.1 → 1.8.0

package/dist/client/Cli.js

@@ -5,34 +5,62 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { Readable } from 'node:stream';
 import { pipeline } from 'node:stream/promises';
+import { clearTimeout } from 'node:timers';
 import path from 'path';
 import * as readline from 'readline';
 import inquirer from 'inquirer';
-import { ProcessException } from '../exceptions.js';
+import { ProcessException, TimeoutException } from '../exceptions.js';
+import { logger } from '../logger.js';
+export const NO_TIMEOUT = 0;
 export class Cli {
-    async run(command, args, out_scanner, in_scanner) {
+    constructor() {
+    }
+    async run(command, args, timeoutMs = NO_TIMEOUT, out_scanner, in_scanner) {
+        const needsInteractive = !!in_scanner;
         const spawnOptions = {
-            stdio: ['pipe', 'pipe', 'pipe'],
+            stdio: [needsInteractive ? 'pipe' : 'ignore', 'pipe', 'pipe'],
         };
         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);
+        const rl = needsInteractive
+            ? readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            })
+            : null;
+        let timeoutId = null;
+        let timedOut = false;
+        if (timeoutMs > 0) {
+            timeoutId = setTimeout(() => {
+                timedOut = true;
+                child.kill('SIGTERM');
+                timeoutId = null;
+            }, timeoutMs);
+        }
+        function clearTimeoutIfNeeded() {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+                timeoutId = null;
+            }
+        }
+        const handlers = [];
+        function on(sig) {
+            const h = () => child.kill(sig);
+            process.on(sig, h);
+            handlers.push([sig, h]);
+        }
+        on('SIGINT');
+        on('SIGTERM');
+        on('SIGHUP');
+        rl?.on('line', (line) => {
+            in_scanner?.(line);
+            if (child.stdin.writable) {
+                child.stdin.write(line + '\n');
             }
-            child.stdin.write(line + '\n');
-        });
-        rl.on('SIGINT', () => {
-            child.kill('SIGINT');
         });
         function processLine(line) {
-            if (out_scanner)
-                out_scanner(line);
+            out_scanner?.(line);
             console.log(line);
         }
         let buffer = '';
@@ -50,24 +78,34 @@ export class Cli {
         child.stderr.on('data', (data) => {
             errorBuffer += data;
         });
+        function cleanup() {
+            for (const [sig, h] of handlers)
+                process.off(sig, h);
+            clearTimeoutIfNeeded();
+            rl?.close();
+        }
         return new Promise((resolve, reject) => {
-            child.on('close', (code) => {
-                rl.close();
+            child.on('close', (code, signal) => {
+                cleanup();
                 if (buffer !== '') {
                     processLine(buffer);
                 }
+                if (timedOut) {
+                    reject(new TimeoutException(`Process killed after timeout of ${timeoutMs}ms`));
+                    return;
+                }
                 if (code === 0) {
                     if (errorBuffer) {
-                        console.warn('Process completed successfully, but there were errors:\n' + errorBuffer);
+                        logger.warn('Process completed successfully, but there were errors:\n' + errorBuffer);
                     }
                     resolve();
                 }
                 else {
-                    reject(new ProcessException(code, errorBuffer));
+                    reject(new ProcessException(code, errorBuffer, signal));
                 }
             });
             child.on('error', (err) => {
-                rl.close();
+                cleanup();
                 const code = err?.errno ?? 1;
                 reject(new ProcessException(code, err.message));
             });

package/dist/client/EnvApiClient.js

@@ -1,4 +1,5 @@
 import { BusinessException, KnownException, NotFoundException } from '../exceptions.js';
+import { logger } from '../logger.js';
 import { EnvStatus } from '../model/index.js';
 import { HttpClient, toUrl } from './HttpClient.js';
 export class EnvApiClient {
@@ -76,7 +77,7 @@ export class EnvApiClient {
         env.status = result.status;
     }
     async delete(key, force = false) {
-        console.log('Sending delete command');
+        logger.info('Sending delete command');
         let result;
         try {
             result = await this.httpClient.fetch(`/ci/env/${key}?force=${force}`, {
@@ -89,7 +90,7 @@ export class EnvApiClient {
             }
             throw error;
         }
-        console.log(result.message);
+        logger.info(result.message);
     }
     async getLogs(key) {
         let result;

package/dist/client/HttpClient.js

@@ -1,4 +1,5 @@
 import { BusinessException, HttpException, NotFoundException } from '../exceptions.js';
+import { logger } from '../logger.js';
 const HOST = 'cli.maintenance.agilecustoms.com';
 export function toUrl(path) {
     return `https://${HOST}/env-api${path}`;
@@ -19,6 +20,10 @@ export class HttpClient {
     }
     async fetch(path, options = {}) {
         const url = toUrl(path);
+        if (!options.method) {
+            options.method = 'GET';
+        }
+        logger.debug(`--> ${options.method} ${url} ${JSON.stringify(options)}`);
         let response;
         try {
             response = await fetch(url, options);
@@ -42,6 +47,6 @@ export class HttpClient {
         if (response.status === 422) {
             throw new BusinessException(message);
         }
-        throw new HttpException(response.status, message);
+        throw new HttpException(message);
     }
 }

package/dist/client/index.js

@@ -1,3 +1,2 @@
 export { EnvApiClient } from './EnvApiClient.js';
 export { HttpClient } from './HttpClient.js';
-export { TerraformAdapter } from './TerraformAdapter.js';

package/dist/commands/_keys.js

@@ -3,5 +3,6 @@ export const _keys = {
     FORCE: 'Force deletion without confirmation',
     KEY: 'Environment name/identifier - taken from remote stake key, must be unique for a given customer',
     KIND: 'Environment kind: complete project (default) or some slice such as tt-core + tt-web',
-    OWNER: 'Environment owner (GH username)'
+    OWNER: 'Environment owner (GH username)',
+    VERBOSE: 'Verbose output (w/ debug logs)'
 };

package/dist/commands/_utils.js

@@ -1,24 +1,21 @@
 import { ExitPromptError } from '@inquirer/core';
 import { AbortedException, KnownException } from '../exceptions.js';
+import { logger } from '../logger.js';
 export function wrap(callable) {
     return async (...args) => {
-        let result;
         try {
-            result = await callable(...args);
+            await callable(...args);
         }
         catch (error) {
             if (error instanceof KnownException) {
-                console.error(error.message);
+                logger.error(error.message);
             }
             else if (error instanceof AbortedException || error instanceof ExitPromptError) {
             }
             else {
-                console.error('Unknown error:', error);
+                logger.error('Unknown error: ' + error);
             }
             process.exit(1);
         }
-        if (result !== undefined) {
-            console.log(result);
-        }
     };
 }

package/dist/commands/configure.js

@@ -1,11 +1,13 @@
 import { Command } from 'commander';
 import inquirer from 'inquirer';
 import { configService } from '../container.js';
+import { _keys } from './_keys.js';
 import { wrap } from './_utils.js';
 export function configure(program) {
     program
         .command('configure')
         .description('Configure user settings on your local machine')
+        .option('-v, --verbose', _keys.VERBOSE)
         .action(wrap(handler));
 }
 async function handler() {

package/dist/commands/createEphemeral.js

@@ -7,6 +7,7 @@ export function createEphemeral(program) {
         .command('create-ephemeral')
         .description('Create bare env w/o resources. Used in CI as first step just to pre-generate token for extension')
         .requiredOption('--key <key>', _keys.KEY)
+        .option('-v, --verbose', _keys.VERBOSE)
         .action(wrap(handler));
 }
 async function handler(options) {

package/dist/commands/delete.js

@@ -9,6 +9,7 @@ export function deleteIt(program) {
         .option('--key <key>', _keys.KEY)
         .option('--force', _keys.FORCE)
         .option('--cwd <cwd>', _keys.CWD)
+        .option('-v, --verbose', _keys.VERBOSE)
         .action(wrap(handler));
 }
 async function handler(options) {

package/dist/commands/deploy.js

@@ -7,6 +7,7 @@ export function deploy(program) {
         .command('deploy')
         .description('Create new or update existing environment')
         .option('--cwd <cwd>', _keys.CWD)
+        .option('-v, --verbose', _keys.VERBOSE)
         .allowUnknownOption(true)
         .argument('[args...]')
         .action(wrap(handler));

package/dist/commands/destroy.js

@@ -11,6 +11,7 @@ export function destroy(program) {
         + ' Main use case - test deletion process, basically that you have enough permissions to delete resources')
         .option('--force', _keys.FORCE)
         .option('--cwd <cwd>', _keys.CWD)
+        .option('-v, --verbose', _keys.VERBOSE)
         .allowUnknownOption(true)
         .argument('[args...]')
         .action(wrap(handler));

package/dist/commands/logs.js

@@ -8,6 +8,7 @@ export function logs(program) {
         .description('Get most recent env destroy logs')
         .option('--key <key>', _keys.KEY)
         .option('--cwd <cwd>', _keys.CWD)
+        .option('-v, --verbose', _keys.VERBOSE)
         .action(wrap(handler));
 }
 async function handler(options) {

package/dist/commands/plan.js

@@ -8,6 +8,7 @@ export function plan(program) {
         .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('--cwd <cwd>', _keys.CWD)
+        .option('-v, --verbose', _keys.VERBOSE)
         .allowUnknownOption(true)
         .argument('[args...]')
         .action(wrap(handler));

package/dist/commands/status.js

@@ -8,6 +8,7 @@ export function status(program) {
         .description('Get env status')
         .option('--key <key>', _keys.KEY)
         .option('--cwd <cwd>', _keys.CWD)
+        .option('-v, --verbose', _keys.VERBOSE)
         .action(wrap(handler));
 }
 async function handler(options) {

package/dist/container.js

@@ -1,7 +1,7 @@
 import { S3Backend } from './backend/S3Backend.js';
 import { Cli } from './client/Cli.js';
-import { EnvApiClient, HttpClient, TerraformAdapter } from './client/index.js';
-import { ConfigService, EnvService } from './service/index.js';
+import { EnvApiClient, HttpClient } from './client/index.js';
+import { ConfigService, EnvService, TerraformAdapter } from './service/index.js';
 import { LocalStateService } from './service/LocalStateService.js';
 import { LogService } from './service/LogService.js';
 const cli = new Cli();
@@ -12,7 +12,7 @@ const backends = [
 const httpClient = new HttpClient();
 const envApiClient = new EnvApiClient(httpClient);
 const localStateService = new LocalStateService();
-const terraformAdapter = new TerraformAdapter(cli, localStateService, backends);
+const terraformAdapter = new TerraformAdapter(Date.now, cli, localStateService, backends);
 const envService = new EnvService(cli, envApiClient, terraformAdapter);
 const logService = new LogService(cli, envApiClient, terraformAdapter);
 export { configService, envService, logService };

package/dist/exceptions.js

@@ -11,34 +11,36 @@ export class AbortedException extends Error {
     }
 }
 export class HttpException extends Error {
-    statusCode;
-    responseBody;
-    constructor(statusCode, responseBody) {
-        super(`Received ${statusCode} response`);
-        this.statusCode = statusCode;
-        this.responseBody = responseBody;
+    constructor(message) {
+        super(message);
         this.name = 'HttpException';
     }
 }
 export class BusinessException extends HttpException {
-    message;
     constructor(message) {
-        super(422, message);
-        this.message = message;
+        super(message);
         this.name = 'BusinessException';
     }
 }
 export class NotFoundException extends HttpException {
     constructor(message) {
-        super(404, message);
+        super(message);
         this.name = 'NotFoundException';
     }
 }
 export class ProcessException extends Error {
     code;
-    constructor(code, message) {
+    signal;
+    constructor(code, message, signal = null) {
         super(message);
         this.code = code;
+        this.signal = signal;
         this.name = 'ProcessException';
     }
 }
+export class TimeoutException extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'TimeoutException';
+    }
+}

package/dist/logger.js

@@ -0,0 +1,36 @@
+export class Logger {
+    now;
+    verbose;
+    buffer = [];
+    constructor(now, verbose) {
+        this.now = now;
+        this.verbose = verbose;
+    }
+    debug(msg) {
+        this.log('debug', msg);
+    }
+    info(msg) {
+        this.log('info', msg);
+    }
+    warn(msg) {
+        this.log('warn', msg);
+    }
+    error(msg) {
+        this.log('error', msg);
+    }
+    log(level, msg) {
+        const date = new Date(this.now()).toISOString();
+        const detailedMessage = `${date} [${level}] ${msg}`;
+        this.buffer.push(detailedMessage);
+        if (!this.verbose && level === 'debug') {
+            return;
+        }
+        const method = console[level];
+        method(this.verbose ? detailedMessage : `${msg}`);
+    }
+    getBuffer() {
+        return this.buffer;
+    }
+}
+const verbose = process.argv.includes('--verbose') || process.argv.includes('-v');
+export const logger = new Logger(Date.now, verbose);

package/dist/service/BaseService.js

@@ -1,4 +1,4 @@
-import { TerraformAdapter } from '../client/index.js';
+import { logger } from '../logger.js';
 export class BaseService {
     terraformAdapter;
     constructor(terraformAdapter) {
@@ -6,7 +6,7 @@ export class BaseService {
     }
     getKey(key) {
         if (!key) {
-            console.log('Key is not provided, inferring from state file');
+            logger.info('Key is not provided, inferring from state file');
             key = this.terraformAdapter.getTerraformBackend().getKey();
         }
         return key;

package/dist/service/EnvService.js

@@ -1,6 +1,7 @@
 import { Cli } from '../client/Cli.js';
-import { EnvApiClient, TerraformAdapter } from '../client/index.js';
+import { EnvApiClient } from '../client/index.js';
 import { KnownException } from '../exceptions.js';
+import { logger } from '../logger.js';
 import { EnvStatus } from '../model/index.js';
 import { BaseService } from './BaseService.js';
 export const PLAN_FILE = '.terraform/envctl.plan';
@@ -14,13 +15,13 @@ export class EnvService extends BaseService {
     }
     async status(key) {
         key = this.getKey(key);
-        console.log(`Retrieve env ${key}`);
+        logger.info(`Retrieve env ${key}`);
         const env = await this.envApi.get(key);
         if (env === null) {
-            console.log(`Env ${key} does not exist`);
+            logger.info(`Env ${key} does not exist`);
             return;
         }
-        console.log(`Env ${key} status: ${env.status}`);
+        logger.info(`Env ${key} status: ${env.status}`);
         if (env.status !== EnvStatus.Deleting && env.status !== EnvStatus.DeleteError) {
             const date = new Date(env.ttl * 1000);
             const formattedDate = date.toLocaleString(undefined, {
@@ -31,23 +32,23 @@ export class EnvService extends BaseService {
                 second: '2-digit',
                 hour12: false,
             });
-            console.log(`Expires at ${formattedDate}`);
+            logger.info(`Expires at ${formattedDate}`);
         }
         if (env.kind) {
             const kind = this.cli.getKind();
             if (env.kind !== kind) {
-                console.warn(`Env ${key} kind (dir-name): ${env.kind} - looks like this env was deployed from a different directory`);
+                logger.warn(`Env ${key} kind (dir-name): ${env.kind} - looks like this env was deployed from a different directory`);
             }
         }
     }
     async tryGetEnv(key) {
-        console.log(`Check if env ${key} already exists`);
+        logger.info(`Check if env ${key} already exists`);
         const env = await this.envApi.get(key);
         if (env) {
-            console.log(`Found ${key} env`);
+            logger.info(`Found ${key} env`);
         }
         else {
-            console.log(`Env ${key} does not exist`);
+            logger.info(`Env ${key} does not exist`);
         }
         return env;
     }
@@ -68,7 +69,8 @@ export class EnvService extends BaseService {
             this.checkKind(env);
             this.handleDeleteStatuses(env);
         }
-        await this.lockTerraform(env, env === null);
+        const newEnv = env === null;
+        await this.lockTerraform(env, newEnv);
         await this.terraformAdapter.plan(env, tfArgs);
     }
     async createEphemeral(key) {
@@ -76,7 +78,7 @@ export class EnvService extends BaseService {
         return await this.envApi.createEphemeral(createEnv);
     }
     async lockTerraform(env, newEnv = false) {
-        console.log('Lock providers');
+        logger.info('Lock providers');
         const res = await this.terraformAdapter.lock(newEnv);
         if (env !== null) {
             if (res.lockFile) {
@@ -122,11 +124,11 @@ export class EnvService extends BaseService {
         let env = await this.tryGetEnv(key);
         if (env === null) {
             const kind = this.cli.getKind();
-            console.log(`Inferred kind from directory name: ${kind}`);
+            logger.info(`Inferred kind from directory name: ${kind}`);
             const createEnv = { key, kind };
             await this.lockTerraform(createEnv, true);
             tfArgs = await this.ensurePlan(env, tfArgs);
-            console.log('Creating env metadata');
+            logger.info('Creating env metadata');
             env = await this.envApi.create(createEnv);
             await this.runDeploy(env, tfArgs);
             return;
@@ -138,16 +140,16 @@ export class EnvService extends BaseService {
             const answerYes = await this.cli.promptYesNo(`Env status is ${status}, likely due to an error from a previous run\n
           Do you want to proceed with deployment?`);
             if (!answerYes) {
-                console.log('Aborting deployment');
+                logger.info('Aborting deployment');
                 return;
             }
         }
         if (status === EnvStatus.Init || status === EnvStatus.Active) {
-            console.log(`Env status is ${status}`);
+            logger.info(`Env status is ${status}`);
             await this.lockTerraform(env);
             tfArgs = await this.ensurePlan(env, tfArgs);
             if (env.status == EnvStatus.Active) {
-                console.log('Will lock for update and run terraform apply (to update resources)');
+                logger.info('Will lock for update and run terraform apply (to update resources)');
             }
             await this.envApi.lockForUpdate(env);
             await this.runDeploy(env, tfArgs);
@@ -157,9 +159,9 @@ export class EnvService extends BaseService {
         await this.runDeploy(env, tfArgs);
     }
     async runDeploy(env, tfArgs) {
-        console.log('Deploying resources');
-        await this.terraformAdapter.apply(tfArgs);
-        console.log('Activating env (to finish creation)');
+        logger.info('Deploying resources');
+        await this.terraformAdapter.apply(tfArgs, env.ttl);
+        logger.info('Activating env (to finish creation)');
         await this.envApi.activate(env);
     }
     async delete(force, key) {
@@ -170,7 +172,7 @@ export class EnvService extends BaseService {
         const key = this.terraformAdapter.getTerraformBackend().getKey();
         const env = await this.get(key);
         if (env.status === EnvStatus.Init) {
-            console.log(`Env ${env.key} status is INIT - no resources, nothing to destroy, just deleting metadata`);
+            logger.info(`Env ${env.key} status is INIT - no resources, nothing to destroy, just deleting metadata`);
             await this.envApi.delete(key, force);
             return;
         }
@@ -178,20 +180,20 @@ export class EnvService extends BaseService {
             throw new KnownException(`Env ${env.key} status is DELETING, please wait or re-run with --force`);
         }
         if (env.status === EnvStatus.Active) {
-            console.log('Lock env to run destroy');
+            logger.info('Lock env to run destroy');
             await this.envApi.lockForUpdate(env);
         }
         await this.terraformAdapter.destroy(env, tfArgs, force);
         await this.envApi.delete(key, force);
-        console.log('Please wait for ~30 sec before you can create env with same name');
+        logger.info('Please wait for ~30 sec before you can create env with same name');
     }
     async get(key) {
-        console.log(`Retrieve env ${key}`);
+        logger.info(`Retrieve env ${key}`);
         const env = await this.envApi.get(key);
         if (!env) {
             throw new KnownException(`Environment ${key} is not found`);
         }
-        console.log(`Env status: ${env.status}`);
+        logger.info(`Env status: ${env.status}`);
         return env;
     }
 }

package/dist/service/LocalStateService.js

@@ -1,5 +1,6 @@
 import * as fs from 'node:fs';
 import path from 'path';
+import { logger } from '../logger.js';
 const CURRENT_VERSION = 1;
 export class LocalStateService {
     config;
@@ -16,16 +17,16 @@ export class LocalStateService {
         if (this.config) {
             return this.config;
         }
-        console.log('Load local state config');
+        logger.info('Load local state config');
         const filePath = this.filePath();
         if (!fs.existsSync(filePath)) {
-            console.warn('Local state file does not exist, must have been accidentally deleted, re-initializing');
+            logger.warn('Local state file does not exist, must have been accidentally deleted, re-initializing');
             return this.createEmptyConfig(filePath);
         }
         const data = fs.readFileSync(filePath, 'utf-8');
         let config = JSON.parse(data);
         if (config.version != CURRENT_VERSION) {
-            console.log('Local state file version mismatch, re-initializing');
+            logger.info('Local state file version mismatch, re-initializing');
             config = this.createEmptyConfig(filePath);
         }
         this.config = config;

package/dist/service/LogService.js

@@ -1,6 +1,7 @@
 import { basename } from 'node:path';
-import { TerraformAdapter } from '../client/index.js';
+import {} from '../client/index.js';
 import { KnownException } from '../exceptions.js';
+import { logger } from '../logger.js';
 import { BaseService } from './BaseService.js';
 export class LogService extends BaseService {
     cli;
@@ -33,7 +34,7 @@ export class LogService extends BaseService {
             throw new KnownException(`Failed to download logs: ${res.status} ${res.statusText}${msg ? ` - ${msg}` : ''}`);
         }
         const outPath = await this.cli.writeInTmpFile(res.body, outName);
-        console.log(`Logs saved to: ${outPath}`);
+        logger.info(`Logs saved to: ${outPath}`);
         await this.cli.run('open', ['-R', outPath]);
     }
 }

package/dist/{client → service}/TerraformAdapter.js

@@ -1,10 +1,12 @@
 import fs from 'fs';
 import { createHash } from 'node:crypto';
 import path from 'path';
-import { AbortedException, KnownException, ProcessException } from '../exceptions.js';
-import { LocalStateService } from '../service/LocalStateService.js';
-const MAX_ATTEMPTS = 2;
-const RETRYABLE_ERRORS = [
+import { NO_TIMEOUT } from '../client/Cli.js';
+import { AbortedException, KnownException, ProcessException, TimeoutException } from '../exceptions.js';
+import { logger } from '../logger.js';
+import { LocalStateService } from './LocalStateService.js';
+export const MAX_ATTEMPTS = 2;
+export const RETRYABLE_ERRORS = [
     'ConcurrentModificationException',
     'public policies are blocked by the BlockPublicPolicy block public access setting',
     'operation error Lambda: AddPermission, https response error StatusCode: 404',
@@ -14,11 +16,13 @@ function hash(data) {
     return createHash('sha256').update(data).digest('hex');
 }
 export class TerraformAdapter {
+    now;
     cli;
     localStateService;
     backends;
     backend = undefined;
-    constructor(cli, localStateService, backends) {
+    constructor(now, cli, localStateService, backends) {
+        this.now = now;
         this.cli = cli;
         this.localStateService = localStateService;
         this.backends = backends.reduce((acc, backend) => {
@@ -100,7 +104,7 @@ export class TerraformAdapter {
         return res;
     }
     async lockProviders() {
-        console.log('Update lock file');
+        logger.info('Update lock file');
         await this.cli.run('terraform', ['providers', 'lock', '-platform=linux_arm64']);
     }
     printTime() {
@@ -109,7 +113,7 @@ export class TerraformAdapter {
         const edt = now.toLocaleString('en-US', {
             timeZone: 'America/New_York'
         });
-        console.log(`\nTime EDT: ${edt},  UTC: ${utc}\n`);
+        logger.info(`\nTime EDT: ${edt},  UTC: ${utc}\n`);
     }
     tfArgs(env, args, vars = []) {
         const varDefs = this.getVarDefs();
@@ -160,7 +164,7 @@ export class TerraformAdapter {
             const keyValue = arg.slice(5);
             const eqIndex = keyValue.indexOf('=');
             if (eqIndex === -1) {
-                console.error('Terraform var argument is not in key=value format:', arg);
+                logger.error('Terraform var argument is not in key=value format: ' + arg);
                 return;
             }
             const key = keyValue.slice(0, eqIndex);
@@ -176,7 +180,7 @@ export class TerraformAdapter {
         Object.entries(vars).forEach(([key, value]) => {
             const varDef = varDefs[key];
             if (!varDef) {
-                console.warn(`Terraform variable ${key} passed, but not found in .tf files`);
+                logger.warn(`Terraform variable ${key} passed, but not found in .tf files`);
                 return;
             }
             if (varDef.sensitive)
@@ -191,9 +195,9 @@ export class TerraformAdapter {
         if (env) {
             args = this.tfArgs(env, args);
         }
-        await this._plan(args, onDemandVars);
+        await this._plan(args, onDemandVars, 1);
     }
-    async _plan(args, onDemandVars, attemptNo = 1) {
+    async _plan(args, onDemandVars, attemptNo) {
         let inputTfVariable = false;
         let tfVarName = '';
         function out_scanner(line) {
@@ -212,32 +216,52 @@ export class TerraformAdapter {
                 tfVarName = '';
             }
         }
-        console.log('Running: terraform plan', ...args, '\n');
+        logger.info('Running: terraform plan ' + args.join(' ') + '\n');
         try {
-            await this.cli.run('terraform', ['plan', ...args], out_scanner, in_scanner);
+            await this.cli.run('terraform', ['plan', ...args], NO_TIMEOUT, out_scanner, in_scanner);
         }
         catch (error) {
             if (!(error instanceof ProcessException)) {
                 throw error;
             }
             if (attemptNo < MAX_ATTEMPTS && RETRYABLE_ERRORS.some(err => error.message.includes(err))) {
-                console.warn(`Retrying terraform plan due to error: ${error.message}`);
+                logger.warn(`Retrying terraform plan due to error: ${error.message}`);
                 return this._plan(args, onDemandVars, attemptNo + 1);
             }
             const lockId = this.lockId(error, attemptNo);
             if (lockId) {
                 await this.promptUnlock(lockId);
-                console.info('State unlocked, retrying terraform plan');
+                logger.info('State unlocked, retrying terraform plan');
                 return this._plan(args, onDemandVars, attemptNo + 1);
             }
             throw new KnownException(`terraform plan failed with code ${error.code}:\n${error.message}`, { cause: error });
         }
     }
-    async apply(args, attemptNo = 1) {
-        console.log('Running: terraform apply', ...args, '\n');
+    async apply(args, ttl) {
+        logger.info('Running: terraform apply ' + args.join(' ') + '\n');
+        try {
+            await this._apply(args, ttl, 1);
+        }
+        catch (error) {
+            if (error instanceof TimeoutException) {
+                throw new KnownException('Reached environment ttl while running \'terraform apply\' command\n'
+                    + 'Command was stopped to avoid race condition with deletion process\n'
+                    + 'Please wait env deletion', { cause: error });
+            }
+            throw error;
+        }
+    }
+    async _apply(args, ttl, attemptNo) {
         this.printTime();
+        const nowUtcSeconds = Math.floor(this.now() / 1000);
+        const gracePeriod = 10;
+        const timeout = (ttl - nowUtcSeconds - gracePeriod) * 1000;
+        if (timeout <= 0) {
+            throw new KnownException('TTL expired before terraform apply could start');
+        }
+        logger.debug('timeout(ms): ' + timeout);
         try {
-            await this.cli.run('terraform', ['apply', ...args]);
+            await this.cli.run('terraform', ['apply', ...args], timeout);
             this.printTime();
         }
         catch (error) {
@@ -245,14 +269,14 @@ export class TerraformAdapter {
                 throw error;
             }
             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(args, attemptNo + 1);
+                logger.warn(`Retrying terraform apply due to error: ${error.message}`);
+                return this._apply(args, ttl, attemptNo + 1);
             }
             const lockId = this.lockId(error, attemptNo);
             if (lockId) {
                 await this.promptUnlock(lockId);
-                console.info('State unlocked, retrying terraform apply');
-                return this.apply(args, attemptNo + 1);
+                logger.info('State unlocked, retrying terraform apply');
+                return this._apply(args, ttl, attemptNo + 1);
             }
             throw new KnownException(`terraform apply failed with code ${error.code}:\n${error.message}`, { cause: error });
         }
@@ -268,9 +292,9 @@ export class TerraformAdapter {
                 wrongDir = true;
             }
         };
-        console.log('Running: terraform destroy -auto-approve', ...args, '\n');
+        logger.info('Running: terraform destroy -auto-approve' + args.join(' ') + '\n');
         try {
-            await this.cli.run('terraform', ['destroy', '-auto-approve', ...args], scanner);
+            await this.cli.run('terraform', ['destroy', '-auto-approve', ...args], NO_TIMEOUT, scanner);
         }
         catch (error) {
             if (!(error instanceof ProcessException)) {
@@ -284,7 +308,7 @@ export class TerraformAdapter {
                 else {
                     await this.promptUnlock(lockId);
                 }
-                console.info('State unlocked, retrying terraform destroy');
+                logger.info('State unlocked, retrying terraform destroy');
                 return this._destroy(args, force, attemptNo + 1);
             }
             throw new KnownException(`terraform destroy failed with code ${error.code}:\n${error.message}`, { cause: error });
@@ -297,7 +321,7 @@ export class TerraformAdapter {
         if (attemptNo < MAX_ATTEMPTS && error.message.includes('Error acquiring the state lock')) {
             const match = error.message.match(/ID:\s+([a-f0-9-]{36})/i);
             if (match) {
-                console.error(error.message);
+                logger.error(error.message);
                 return match[1];
             }
         }
@@ -312,7 +336,7 @@ export class TerraformAdapter {
         await this.forceUnlock(id);
     }
     async forceUnlock(id) {
-        console.log('Force unlocking state');
+        logger.info('Force unlocking state');
         await this.cli.run('terraform', ['force-unlock', '-force', id]);
     }
 }

package/dist/service/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agilecustoms/envctl",
-  "version": "1.6.1",
+  "version": "1.8.0",
   "description": "node.js CLI client for manage environments",
   "keywords": [
     "terraform wrapper",
@@ -37,11 +37,12 @@
     "test": "vitest run --coverage",
     "build": "tsc -p tsconfig.build.json",
     "run": "tsc -p tsconfig.build.json --sourceMap true && node dist/index.js",
+    "run-help": "     npm run run -- deploy --help",
     "run-version": "  npm run run -- --version",
     "run-configure": "npm run run -- configure",
     "~": "",
     "run-core-init": "  cd ../tt-core && terraform init -upgrade -backend-config=key=laxa1986 -reconfigure",
-    "run-core-status": " npm run run -- status  --cwd ../tt-core",
+    "run-core-status": " npm run run -- status  --cwd ../tt-core -v",
     "run-core-plan": "   npm run run -- plan    --cwd ../tt-core -out=.terraform/plan",
     "run-core-deployp": "npm run run -- deploy  --cwd ../tt-core .terraform/plan",
     "run-core-deploy": " npm run run -- deploy  --cwd ../tt-core -var=\"env_size=min\"",