@agilecustoms/envctl 1.13.3 → 1.14.0

package/dist/client/Cli.js

@@ -8,7 +8,6 @@ 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, TimeoutException } from '../exceptions.js';
 import { logger } from '../logger.js';
 export const NO_TIMEOUT = 0;
@@ -111,15 +110,6 @@ export class Cli {
             });
         });
     }
-    async promptYesNo(message, defaultValue = false) {
-        const { answer } = await inquirer.prompt([{
-                type: 'confirm',
-                name: 'answer',
-                message,
-                default: defaultValue,
-            }]);
-        return answer;
-    }
     getKind() {
         return path.basename(process.cwd());
     }

package/dist/commands/_keys.js

@@ -1,5 +1,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'
+    KIND: 'Environment kind',
+    PROFILE: 'Profile to use'
 };

package/dist/commands/configure.js

@@ -1,5 +1,5 @@
+import { input, password } from '@inquirer/prompts';
 import { Command } from 'commander';
-import inquirer from 'inquirer';
 import { ConfigService } from '../service/index.js';
 import { wrap } from './_utils.js';
 export function configure(program, configService) {
@@ -7,15 +7,10 @@ export function configure(program, configService) {
         .command('configure')
         .description('Configure user settings on your local machine')
         .action(wrap(async () => {
-        const answers = await inquirer.prompt([
-            {
-                type: 'password',
-                name: 'apiKey',
-                message: 'apiKey is required to deploy any env\n'
-                    + '(prefer GitHub username)\n'
-                    + 'apiKey:',
-            },
-        ]);
-        configService.saveConfig({ apiKey: answers.apiKey });
+        const profile = await input({ message: 'Profile name', default: 'default', required: true });
+        const apiKey = await password({ message: 'API key', mask: true });
+        const varKey = await input({ message: 'Terraform variable to auto populate with remote state key (empty to skip)' });
+        const varEphemeral = await input({ message: 'Terraform variable to auto populate with flag "ephemeral" (empty to skip)' });
+        configService.saveConfig(profile, { apiKey, varKey, varEphemeral });
     }));
 }

package/dist/commands/createEphemeral.js

@@ -7,9 +7,10 @@ export function createEphemeral(program, configService, envService) {
         .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('--profile <profile>', _keys.PROFILE)
         .action(wrap(async (options) => {
-        configService.checkApiKey();
-        const { key } = options;
+        const { key, profile } = options;
+        configService.init(profile);
         const token = await envService.createEphemeral(key);
         console.log(token);
     }));

package/dist/commands/delete.js

@@ -8,9 +8,10 @@ export function deleteIt(program, configService, envService) {
         .description('Delete a development environment')
         .option('--key <key>', _keys.KEY)
         .option('--force', _keys.FORCE)
+        .option('--profile <profile>', _keys.PROFILE)
         .action(wrap(async (options) => {
-        configService.checkApiKey();
-        const { key, force } = options;
+        const { key, force, profile } = options;
+        configService.init(profile);
         await envService.delete(Boolean(force), key);
     }));
 }

package/dist/commands/deploy.js

@@ -1,14 +1,17 @@
 import { Command } from 'commander';
 import { ConfigService, EnvService } from '../service/index.js';
+import { _keys } from './_keys.js';
 import { wrap } from './_utils.js';
 export function deploy(program, configService, envService) {
     program
         .command('deploy')
         .description('Create new or update existing environment')
+        .option('--profile <profile>', _keys.PROFILE)
         .allowUnknownOption(true)
         .argument('[args...]')
-        .action(wrap(async (tfArgs) => {
-        configService.checkApiKey();
+        .action(wrap(async (tfArgs, options) => {
+        const { profile } = options;
+        configService.init(profile);
         await envService.deploy(tfArgs);
     }));
 }

package/dist/commands/destroy.js

@@ -10,11 +10,12 @@ export function destroy(program, configService, envService) {
         + ' Unlike "delete" command, this command doesn\'t have --key option, it can only delete env after key you provided during terraform init.'
         + ' Main use case - test deletion process, basically that you have enough permissions to delete resources')
         .option('--force', _keys.FORCE)
+        .option('--profile <profile>', _keys.PROFILE)
         .allowUnknownOption(true)
         .argument('[args...]')
         .action(wrap(async (tfArgs, options) => {
-        configService.checkApiKey();
-        const { force } = options;
+        const { force, profile } = options;
+        configService.init(profile);
         await envService.destroy(tfArgs, Boolean(force));
     }));
 }

package/dist/commands/logs.js

@@ -7,9 +7,10 @@ export function logs(program, configService, logService) {
         .command('logs')
         .description('Get most recent env destroy logs')
         .option('--key <key>', _keys.KEY)
+        .option('--profile <profile>', _keys.PROFILE)
         .action(wrap(async (options) => {
-        configService.checkApiKey();
-        const { key } = options;
+        const { key, profile } = options;
+        configService.init(profile);
         await logService.getLogs(key);
     }));
 }

package/dist/commands/plan.js

@@ -1,14 +1,18 @@
 import { Command } from 'commander';
-import { EnvService } from '../service/index.js';
+import { ConfigService, EnvService } from '../service/index.js';
+import { _keys } from './_keys.js';
 import { wrap } from './_utils.js';
-export function plan(program, envService) {
+export function plan(program, configService, envService) {
     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('--profile <profile>', _keys.PROFILE)
         .allowUnknownOption(true)
         .argument('[args...]')
-        .action(wrap(async (tfArgs) => {
+        .action(wrap(async (tfArgs, options) => {
+        const { profile } = options;
+        configService.init(profile);
         await envService.plan(tfArgs);
     }));
 }

package/dist/commands/status.js

@@ -6,9 +6,11 @@ export function status(program, configService, envService) {
     program
         .command('status')
         .description('Get env status')
+        .option('--profile <profile>', _keys.PROFILE)
         .argument('[key]', _keys.KEY)
-        .action(wrap(async (key) => {
-        configService.checkApiKey();
+        .action(wrap(async (key, options) => {
+        const { profile } = options;
+        configService.init(profile);
         await envService.status(key);
     }));
 }

package/dist/container.js

@@ -14,7 +14,7 @@ export function buildContainer(appVersion) {
     const envApiClient = new EnvApiClient(httpClient);
     const localStateService = new LocalStateService();
     const nonInteractive = !process.stdout.isTTY || process.env.CI === 'true';
-    const terraformAdapter = new TerraformAdapter(Date.now, cli, localStateService, backends, nonInteractive);
+    const terraformAdapter = new TerraformAdapter(Date.now, configService, cli, localStateService, backends, nonInteractive);
     const envService = new EnvService(cli, envApiClient, terraformAdapter);
     const logService = new LogService(cli, envApiClient, terraformAdapter);
     return { configService, envService, logService };

package/dist/index.js

@@ -23,6 +23,6 @@ deleteIt(program, configService, envService);
 deploy(program, configService, envService);
 destroy(program, configService, envService);
 logs(program, configService, logService);
-plan(program, envService);
+plan(program, configService, envService);
 status(program, configService, envService);
 program.parse(process.argv);

package/dist/service/ConfigService.js

@@ -2,11 +2,11 @@ import * as fs from 'node:fs';
 import * as os from 'node:os';
 import path from 'path';
 import { KnownException } from '../exceptions.js';
-const CONFIG_PATH = path.join(os.homedir(), '.envctl', 'default.json');
+const CONFIG_DIR = path.join(os.homedir(), '.envctl');
 var EnvKey;
 (function (EnvKey) {
-    EnvKey["ENV_API_KEY"] = "ENVCTL_API_KEY";
-    EnvKey["ENV_MAP_KEY_TO"] = "ENVCTL_MAP_KEY_TO";
+    EnvKey["API_KEY"] = "ENVCTL_API_KEY";
+    EnvKey["PROFILE"] = "ENVCTL_PROFILE";
 })(EnvKey || (EnvKey = {}));
 function env(key) {
     return process.env[key];
@@ -18,36 +18,47 @@ 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() {
+    loadConfig(profile) {
         if (this.config)
-            return this.config;
-        if (fs.existsSync(CONFIG_PATH)) {
-            const data = fs.readFileSync(CONFIG_PATH, 'utf-8');
+            throw new Error('load config second time?');
+        if (!profile) {
+            profile = env(EnvKey.PROFILE) || 'default';
+        }
+        const configPath = path.join(CONFIG_DIR, `${profile}.json`);
+        if (fs.existsSync(configPath)) {
+            const data = fs.readFileSync(configPath, 'utf-8');
             this.config = JSON.parse(data);
-            return this.config;
         }
-        return null;
+        return this.config;
     }
-    getApiKey() {
-        let apiKey = env(EnvKey.ENV_API_KEY);
-        if (!apiKey) {
-            apiKey = this.loadConfig()?.apiKey;
-        }
-        return apiKey;
+    saveConfig(profile, config) {
+        const mergedConfig = { ...this.loadConfig(profile), ...config };
+        const data = JSON.stringify(mergedConfig, null, 2);
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+        const configPath = path.join(CONFIG_DIR, `${profile}.json`);
+        fs.writeFileSync(configPath, data);
     }
-    checkApiKey() {
+    init(profile) {
+        this.loadConfig(profile);
         const apiKey = this.getApiKey();
         if (!apiKey) {
             if (isCI()) {
-                throw new KnownException('API key is missing, set env variable ' + EnvKey.ENV_API_KEY);
+                throw new KnownException('API key is missing, set env variable ' + EnvKey.API_KEY);
             }
-            throw new KnownException('API key is missing, call \'envctl configure\' or set env variable ' + EnvKey.ENV_API_KEY);
+            throw new KnownException('API key is missing, call \'envctl configure\' or set env variable ' + EnvKey.API_KEY);
         }
     }
+    getApiKey() {
+        let apiKey = env(EnvKey.API_KEY);
+        if (!apiKey) {
+            apiKey = this.config?.apiKey;
+        }
+        return apiKey;
+    }
+    getVarKey() {
+        return this.config?.varKey;
+    }
+    getVarEphemeral() {
+        return this.config?.varEphemeral;
+    }
 }

package/dist/service/EnvService.js

@@ -1,3 +1,4 @@
+import { confirm } from '@inquirer/prompts';
 import { Cli } from '../client/Cli.js';
 import { EnvApiClient } from '../client/index.js';
 import { KnownException } from '../exceptions.js';
@@ -129,8 +130,9 @@ export class EnvService extends BaseService {
         this.handleDeleteStatuses(env);
         const status = env.status;
         if (status === EnvStatus.Deploying || status === EnvStatus.Updating) {
-            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?`);
+            const message = `Env status is ${status}, likely due to an error from a previous run\n
+          Do you want to proceed with deployment?`;
+            const answerYes = await confirm({ message });
             if (!answerYes) {
                 logger.info('Aborting deployment');
                 return;

package/dist/service/TerraformAdapter.js

@@ -1,6 +1,7 @@
 import fs from 'fs';
 import { createHash } from 'node:crypto';
 import path from 'path';
+import { confirm } from '@inquirer/prompts';
 import { NO_TIMEOUT } from '../client/Cli.js';
 import { AbortedException, KnownException, ProcessException, TimeoutException } from '../exceptions.js';
 import { logger } from '../logger.js';
@@ -17,13 +18,15 @@ function hash(data) {
 }
 export class TerraformAdapter {
     now;
+    configService;
     cli;
     localStateService;
     nonInteractive;
     backends;
     backend = undefined;
-    constructor(now, cli, localStateService, backends, nonInteractive) {
+    constructor(now, configService, cli, localStateService, backends, nonInteractive) {
         this.now = now;
+        this.configService = configService;
         this.cli = cli;
         this.localStateService = localStateService;
         this.nonInteractive = nonInteractive;
@@ -120,9 +123,20 @@ export class TerraformAdapter {
     tfArgs(env, args, vars = []) {
         const varDefs = this.getVarDefs();
         const argVars = this.getArgVars(args);
-        const specialFields = { env: env.key, ephemeral: env.ephemeral };
         const extraArgs = [];
-        for (const name of ['env', 'ephemeral']) {
+        if (this.nonInteractive && !args.some(arg => arg.startsWith('-input'))) {
+            extraArgs.push('-input=false');
+        }
+        const specialFields = {};
+        const varKey = this.configService.getVarKey();
+        if (varKey) {
+            specialFields[varKey] = env.key;
+        }
+        const varEphemeral = this.configService.getVarEphemeral();
+        if (varEphemeral) {
+            specialFields[varEphemeral] = String(env.ephemeral);
+        }
+        for (const name of Object.keys(specialFields)) {
             if (varDefs[name] && !argVars[name]) {
                 extraArgs.push('-var=' + name + '=' + specialFields[name]);
             }
@@ -132,9 +146,6 @@ export class TerraformAdapter {
                 extraArgs.push('-var=' + key + '=' + value);
             }
         });
-        if (this.nonInteractive && !args.some(arg => arg.startsWith('-input'))) {
-            extraArgs.push('-input=false');
-        }
         return [...extraArgs, ...args];
     }
     getVarDefs() {
@@ -177,25 +188,6 @@ export class TerraformAdapter {
         });
         return result;
     }
-    getNewVars(args, envVars, onDemandVars) {
-        const varDefs = this.getVarDefs();
-        const argVars = this.getArgVars(args);
-        const vars = { ...argVars, ...onDemandVars };
-        const newVars = {};
-        Object.entries(vars).forEach(([key, value]) => {
-            const varDef = varDefs[key];
-            if (!varDef) {
-                logger.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, args, onDemandVars = {}) {
         args = this.tfArgs(env, args);
         await this._plan(args, onDemandVars, 1);
@@ -330,9 +322,10 @@ export class TerraformAdapter {
         }
     }
     async promptUnlock(id) {
-        const answerYes = await this.cli.promptYesNo('Terraform state is locked. Most often due to previously interrupted process.\n'
+        const message = 'Terraform state is locked. Most often due to previously interrupted process.\n'
             + 'Rarely (main lock intention) is when another process actively work with the state to avoid inconsistent modification.\n'
-            + 'Do you want to force unlock?: ');
+            + 'Do you want to force unlock?: ';
+        const answerYes = await confirm({ message });
         if (!answerYes) {
             throw new AbortedException();
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agilecustoms/envctl",
-  "version": "1.13.3",
+  "version": "1.14.0",
   "description": "node.js CLI client for manage environments",
   "keywords": [
     "terraform wrapper",
@@ -66,7 +66,7 @@
   },
   "dependencies": {
     "commander": "^14.0.0",
-    "inquirer": "^13.0.0",
+    "@inquirer/prompts": "^8.0.0",
     "update-notifier": "^7.3.1"
   },
   "devDependencies": {