@agilecustoms/envctl 1.9.0 → 1.10.1

package/dist/client/HttpClient.js

@@ -1,4 +1,3 @@
-import { randomUUID } from 'node:crypto';
 import { BusinessException, HttpException, NotFoundException } from '../exceptions.js';
 import { logger } from '../logger.js';
 const HOST = 'cli.maintenance.agilecustoms.com';
@@ -6,8 +5,12 @@ export function toUrl(path) {
     return `https://${HOST}/env-api${path}`;
 }
 export class HttpClient {
-    commandId = randomUUID();
-    constructor() { }
+    version;
+    commandId;
+    constructor(version, commandId) {
+        this.version = version;
+        this.commandId = commandId;
+    }
     async post(path, body, options = {}) {
         options.method = 'POST';
         if (body) {
@@ -24,15 +27,14 @@ export class HttpClient {
         const url = toUrl(path);
         const headers = new Headers(options.headers);
         headers.set('x-command-id', this.commandId);
+        headers.set('x-client-version', this.version);
         const req = {
             ...options,
             method: options.method ?? 'GET',
             headers,
         };
-        logger.debug(`--> ${req.method} ${url} ${JSON.stringify({
-            ...req,
-            headers: Object.fromEntries(headers.entries()),
-        })}`);
+        const reqJson = JSON.stringify({ ...req, headers: Object.fromEntries(headers.entries()) });
+        logger.debug(`--> ${req.method} ${url} ${reqJson}`);
         let response;
         try {
             response = await fetch(url, options);

package/dist/commands/_keys.js

@@ -1,5 +1,4 @@
 export const _keys = {
-    CWD: 'Working directory (default: current directory)',
     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',

package/dist/commands/configure.js

@@ -1,24 +1,23 @@
 import { Command } from 'commander';
 import inquirer from 'inquirer';
-import { configService } from '../container.js';
+import { ConfigService } from '../service/index.js';
 import { _keys } from './_keys.js';
 import { wrap } from './_utils.js';
-export function configure(program) {
+export function configure(program, configService) {
     program
         .command('configure')
         .description('Configure user settings on your local machine')
         .option('-v, --verbose', _keys.VERBOSE)
-        .action(wrap(handler));
-}
-async function handler() {
-    const answers = await inquirer.prompt([
-        {
-            type: 'input',
-            name: 'userName',
-            message: 'userName is required to deploy any env\n'
-                + '(prefer GitHub username)\n'
-                + 'userName:',
-        },
-    ]);
-    configService.saveConfig({ userName: answers.userName });
+        .action(wrap(async () => {
+        const answers = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'userName',
+                message: 'userName is required to deploy any env\n'
+                    + '(prefer GitHub username)\n'
+                    + 'userName:',
+            },
+        ]);
+        configService.saveConfig({ userName: answers.userName });
+    }));
 }

package/dist/commands/createEphemeral.js

@@ -1,17 +1,16 @@
 import { Command } from 'commander';
-import { envService } from '../container.js';
+import { EnvService } from '../service/index.js';
 import { _keys } from './_keys.js';
 import { wrap } from './_utils.js';
-export function createEphemeral(program) {
+export function createEphemeral(program, envService) {
     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) {
-    const { key } = options;
-    const token = await envService.createEphemeral(key);
-    console.log(token);
+        .action(wrap(async (options) => {
+        const { key } = options;
+        const token = await envService.createEphemeral(key);
+        console.log(token);
+    }));
 }

package/dist/commands/delete.js

@@ -1,20 +1,16 @@
 import { Command } from 'commander';
-import { envService } from '../container.js';
+import { EnvService } from '../service/index.js';
 import { _keys } from './_keys.js';
 import { wrap } from './_utils.js';
-export function deleteIt(program) {
+export function deleteIt(program, envService) {
     program
         .command('delete')
         .description('Delete a development environment')
         .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) {
-    const { key, force, cwd } = options;
-    if (cwd)
-        process.chdir(cwd);
-    await envService.delete(Boolean(force), key);
+        .action(wrap(async (options) => {
+        const { key, force } = options;
+        await envService.delete(Boolean(force), key);
+    }));
 }

package/dist/commands/deploy.js

@@ -1,20 +1,15 @@
 import { Command } from 'commander';
-import { envService } from '../container.js';
+import { EnvService } from '../service/index.js';
 import { _keys } from './_keys.js';
 import { wrap } from './_utils.js';
-export function deploy(program) {
+export function deploy(program, envService) {
     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));
-}
-async function handler(tfArgs, options) {
-    const { cwd } = options;
-    if (cwd)
-        process.chdir(cwd);
-    await envService.deploy(tfArgs);
+        .action(wrap(async (tfArgs) => {
+        await envService.deploy(tfArgs);
+    }));
 }

package/dist/commands/destroy.js

@@ -1,8 +1,8 @@
 import { Command } from 'commander';
-import { envService } from '../container.js';
+import { EnvService } from '../service/index.js';
 import { _keys } from './_keys.js';
 import { wrap } from './_utils.js';
-export function destroy(program) {
+export function destroy(program, envService) {
     program
         .command('destroy')
         .description('Destroy environment resources. This is thin wrapper for terraform destroy.'
@@ -10,15 +10,11 @@ export function destroy(program) {
         + ' 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('--cwd <cwd>', _keys.CWD)
         .option('-v, --verbose', _keys.VERBOSE)
         .allowUnknownOption(true)
         .argument('[args...]')
-        .action(wrap(handler));
-}
-async function handler(tfArgs, options) {
-    const { force, cwd } = options;
-    if (cwd)
-        process.chdir(cwd);
-    await envService.destroy(tfArgs, Boolean(force));
+        .action(wrap(async (tfArgs, options) => {
+        const { force } = options;
+        await envService.destroy(tfArgs, Boolean(force));
+    }));
 }

package/dist/commands/logs.js

@@ -1,19 +1,14 @@
 import { Command } from 'commander';
-import { logService } from '../container.js';
 import { _keys } from './_keys.js';
 import { wrap } from './_utils.js';
-export function logs(program) {
+export function logs(program, logService) {
     program
         .command('logs')
         .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) {
-    const { key, cwd } = options;
-    if (cwd)
-        process.chdir(cwd);
-    await logService.getLogs(key);
+        .action(wrap(async (options) => {
+        const { key } = options;
+        await logService.getLogs(key);
+    }));
 }

package/dist/commands/plan.js

@@ -1,21 +1,16 @@
 import { Command } from 'commander';
-import { envService } from '../container.js';
+import { EnvService } from '../service/index.js';
 import { _keys } from './_keys.js';
 import { wrap } from './_utils.js';
-export function plan(program) {
+export function plan(program, 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('--cwd <cwd>', _keys.CWD)
         .option('-v, --verbose', _keys.VERBOSE)
         .allowUnknownOption(true)
         .argument('[args...]')
-        .action(wrap(handler));
-}
-async function handler(tfArgs, options) {
-    const { cwd } = options;
-    if (cwd)
-        process.chdir(cwd);
-    await envService.plan(tfArgs);
+        .action(wrap(async (tfArgs) => {
+        await envService.plan(tfArgs);
+    }));
 }

package/dist/commands/status.js

@@ -1,19 +1,15 @@
 import { Command } from 'commander';
-import { envService } from '../container.js';
+import { EnvService } from '../service/index.js';
 import { _keys } from './_keys.js';
 import { wrap } from './_utils.js';
-export function status(program) {
+export function status(program, envService) {
     program
         .command('status')
         .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) {
-    const { key, cwd } = options;
-    if (cwd)
-        process.chdir(cwd);
-    await envService.status(key);
+        .action(wrap(async (options) => {
+        const { key } = options;
+        await envService.status(key);
+    }));
 }

package/dist/container.js

@@ -1,18 +1,20 @@
+import { randomUUID } from 'node:crypto';
 import { S3Backend } from './backend/S3Backend.js';
 import { Cli } from './client/Cli.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();
-const configService = new ConfigService();
-const backends = [
-    new S3Backend()
-];
-const httpClient = new HttpClient();
-const envApiClient = new EnvApiClient(httpClient);
-const localStateService = new LocalStateService();
-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 };
+export function buildContainer(appVersion) {
+    const cli = new Cli();
+    const configService = new ConfigService();
+    const backends = [new S3Backend()];
+    const commandId = randomUUID();
+    const httpClient = new HttpClient(appVersion, commandId);
+    const envApiClient = new EnvApiClient(httpClient);
+    const localStateService = new LocalStateService();
+    const terraformAdapter = new TerraformAdapter(Date.now, cli, localStateService, backends);
+    const envService = new EnvService(cli, envApiClient, terraformAdapter);
+    const logService = new LogService(cli, envApiClient, terraformAdapter);
+    return { configService, envService, logService };
+}

package/dist/index.js

@@ -3,20 +3,22 @@ import { createRequire } from 'module';
 import { Command } from 'commander';
 import updateNotifier from 'update-notifier';
 import { configure, createEphemeral, deleteIt, deploy, destroy, logs, plan, status } from './commands/index.js';
+import { buildContainer } from './container.js';
 const require = createRequire(import.meta.url);
 const pkg = require('../package.json');
 updateNotifier({ pkg, updateCheckInterval: 0 }).notify();
+if (process.env.TEST_CWD) {
+    process.chdir(process.env.TEST_CWD);
+}
+const { configService, envService, logService } = buildContainer(pkg.version);
 const program = new Command();
-program
-    .name('envctl')
-    .description('CLI to manage environments')
-    .version(pkg.version);
-configure(program);
-createEphemeral(program);
-deleteIt(program);
-deploy(program);
-destroy(program);
-logs(program);
-plan(program);
-status(program);
+program.name('envctl').description('CLI to manage environments').version(pkg.version);
+configure(program, configService);
+createEphemeral(program, envService);
+deleteIt(program, envService);
+deploy(program, envService);
+destroy(program, envService);
+logs(program, logService);
+plan(program, envService);
+status(program, envService);
 program.parse(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agilecustoms/envctl",
-  "version": "1.9.0",
+  "version": "1.10.1",
   "description": "node.js CLI client for manage environments",
   "keywords": [
     "terraform wrapper",
@@ -36,33 +36,33 @@
     "lint:fix": "npm run lint -- --fix",
     "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",
+    "it": "tsc -p tsconfig.build.json --sourceMap true && TEST_CWD=\"$CWD\" node dist/index.js",
+    "run-help": "     npm run it -- deploy --help",
+    "run-version": "  npm run it -- --version",
+    "run-configure": "npm run it -- 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 -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\"",
-    "run-core-delete": " npm run run -- delete  --cwd ../tt-core",
-    "run-core-destroy": "npm run run -- destroy --cwd ../tt-core",
-    "run-core-logs": "   npm run run -- logs    --cwd ../tt-core",
+    "run-core-status": " CWD=../tt-core npm run it -- status -v",
+    "run-core-plan": "   CWD=../tt-core npm run it -- plan -out=.terraform/plan",
+    "run-core-deployp": "CWD=../tt-core npm run it -- deploy .terraform/plan",
+    "run-core-deploy": " CWD=../tt-core npm run it -- deploy -var=\"env_size=min\"",
+    "run-core-delete": " CWD=../tt-core npm run it -- delete",
+    "run-core-destroy": "CWD=../tt-core npm run it -- destroy",
+    "run-core-logs": "   CWD=../tt-core npm run it -- logs",
     "*": "",
     "run-init": "cd ../tt-gitops && terraform init -upgrade -backend-config=key=laxa1986 -reconfigure",
-    "run-status": "                                 npm run run -- status  --cwd ../tt-gitops",
-    "run-plan": "   AWS_PROFILE=ac-tt-dev-deployer  npm run run -- plan    --cwd ../tt-gitops -var=\"env_size=min\" -var-file=versions.tfvars",
-    "run-deploy": " AWS_PROFILE=ac-tt-dev-deployer  npm run run -- deploy  --cwd ../tt-gitops -var=\"env_size=min\" -var-file=versions.tfvars",
-    "run-delete": "                                 npm run run -- delete  --cwd ../tt-gitops",
-    "run-destroy": "AWS_PROFILE=ac-tt-dev-destroyer npm run run -- destroy --cwd ../tt-gitops -var=\"env_size=min\" -var-file=versions.tfvars",
+    "run-status": "                                 CWD=../tt-gitops npm run it -- status",
+    "run-plan": "   AWS_PROFILE=ac-tt-dev-deployer  CWD=../tt-gitops npm run it -- plan -var=\"env_size=min\" -var-file=versions.tfvars",
+    "run-deploy": " AWS_PROFILE=ac-tt-dev-deployer  CWD=../tt-gitops npm run it -- deploy -var=\"env_size=min\" -var-file=versions.tfvars",
+    "run-delete": "                                 CWD=../tt-gitops npm run it -- delete",
+    "run-destroy": "AWS_PROFILE=ac-tt-dev-destroyer CWD=../tt-gitops npm run it -- destroy -var=\"env_size=min\" -var-file=versions.tfvars",
     "-": "",
-    "run-ephemeral-create": " npm run run -- create-ephemeral --key test",
+    "run-ephemeral-create": " npm run it -- create-ephemeral --key test",
     "run-ephemeral-init": "cd ../tt-gitops && terraform init -upgrade -backend-config=key=test -reconfigure",
-    "run-ephemeral-status": " npm run run -- status --key test",
-    "run-ephemeral-deploy": " npm run run -- deploy  --cwd ../tt-gitops -var-file=versions.tfvars",
-    "run-ephemeral-delete": " npm run run -- delete  --cwd ../tt-gitops --force",
-    "run-ephemeral-destroy": "npm run run -- destroy --cwd ../tt-gitops --force -var-file=versions.tfvars"
+    "run-ephemeral-status": " CWD=../tt-gitops npm run it -- status --key test",
+    "run-ephemeral-deploy": " CWD=../tt-gitops npm run it -- deploy -var-file=versions.tfvars",
+    "run-ephemeral-delete": " CWD=../tt-gitops npm run it -- delete --force",
+    "run-ephemeral-destroy": "CWD=../tt-gitops npm run it -- destroy --force -var-file=versions.tfvars"
   },
   "dependencies": {
     "commander": "^14.0.0",