@agilecustoms/envctl 1.7.0 → 1.8.0

package/dist/client/Cli.js

@@ -10,8 +10,11 @@ import path from 'path';
 import * as readline from 'readline';
 import inquirer from 'inquirer';
 import { ProcessException, TimeoutException } from '../exceptions.js';
+import { logger } from '../logger.js';
 export const NO_TIMEOUT = 0;
 export class Cli {
+    constructor() {
+    }
     async run(command, args, timeoutMs = NO_TIMEOUT, out_scanner, in_scanner) {
         const needsInteractive = !!in_scanner;
         const spawnOptions = {
@@ -93,7 +96,7 @@ export class Cli {
                 }
                 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();
                 }

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);

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/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,3 +1,4 @@
+import { logger } from '../logger.js';
 export class BaseService {
     terraformAdapter;
     constructor(terraformAdapter) {
@@ -5,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 } 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;
     }
@@ -77,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) {
@@ -123,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;
@@ -139,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);
@@ -158,9 +159,9 @@ export class EnvService extends BaseService {
         await this.runDeploy(env, tfArgs);
     }
     async runDeploy(env, tfArgs) {
-        console.log('Deploying resources');
+        logger.info('Deploying resources');
         await this.terraformAdapter.apply(tfArgs, env.ttl);
-        console.log('Activating env (to finish creation)');
+        logger.info('Activating env (to finish creation)');
         await this.envApi.activate(env);
     }
     async delete(force, key) {
@@ -171,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;
         }
@@ -179,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 {} 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/service/TerraformAdapter.js

@@ -3,6 +3,7 @@ import { createHash } from 'node:crypto';
 import path from 'path';
 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 = [
@@ -103,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() {
@@ -112,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();
@@ -163,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);
@@ -179,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)
@@ -215,7 +216,7 @@ 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], NO_TIMEOUT, out_scanner, in_scanner);
         }
@@ -224,20 +225,20 @@ export class TerraformAdapter {
                 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, ttl) {
-        console.log('Running: terraform apply', ...args, '\n');
+        logger.info('Running: terraform apply ' + args.join(' ') + '\n');
         try {
             await this._apply(args, ttl, 1);
         }
@@ -258,7 +259,7 @@ export class TerraformAdapter {
         if (timeout <= 0) {
             throw new KnownException('TTL expired before terraform apply could start');
         }
-        console.debug('timeout: ', timeout);
+        logger.debug('timeout(ms): ' + timeout);
         try {
             await this.cli.run('terraform', ['apply', ...args], timeout);
             this.printTime();
@@ -268,13 +269,13 @@ 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}`);
+                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');
+                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 });
@@ -291,7 +292,7 @@ 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], NO_TIMEOUT, scanner);
         }
@@ -307,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 });
@@ -320,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];
             }
         }
@@ -335,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agilecustoms/envctl",
-  "version": "1.7.0",
+  "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\"",