@agilecustoms/envctl 1.1.1 → 1.3.0

package/dist/client/{ProcessRunner.js → Cli.js}

@@ -1,7 +1,22 @@
 import { spawn } from 'child_process';
+import path from 'path';
 import * as readline from 'readline';
+import inquirer from 'inquirer';
 import { ProcessException } from '../exceptions.js';
-export class ProcessRunner {
+function getDirName(cwd) {
+    cwd = resolveCwd(cwd);
+    return path.basename(cwd);
+}
+function resolveCwd(cwd) {
+    if (!cwd) {
+        return process.cwd();
+    }
+    if (path.isAbsolute(cwd)) {
+        return cwd;
+    }
+    return path.resolve(process.cwd(), cwd);
+}
+export class Cli {
     async run(command, args, cwd, out_scanner, in_scanner) {
         const spawnOptions = {
             stdio: ['pipe', 'pipe', 'pipe'],
@@ -68,4 +83,16 @@ export class ProcessRunner {
             });
         });
     }
+    async promptYesNo(message, defaultValue = false) {
+        const { answer } = await inquirer.prompt([{
+                type: 'confirm',
+                name: 'answer',
+                message,
+                default: defaultValue,
+            }]);
+        return answer;
+    }
+    getKind(cwd) {
+        return getDirName(cwd);
+    }
 }

package/dist/client/EnvApiClient.js

@@ -1,6 +1,6 @@
-import { KnownException, NotFoundException } from '../exceptions.js';
+import { BusinessException, KnownException, NotFoundException } from '../exceptions.js';
 import { EnvStatus } from '../model/index.js';
-import { HttpClient } from './HttpClient.js';
+import { HttpClient, toUrl } from './HttpClient.js';
 export class EnvApiClient {
     httpClient;
     constructor(httpClient) {
@@ -18,19 +18,53 @@ export class EnvApiClient {
         }
     }
     async createEphemeral(env) {
-        const { token } = await this.httpClient.post('/ci/env-ephemeral', env);
-        return token;
+        let result;
+        try {
+            result = await this.httpClient.post('/ci/env-ephemeral', env);
+        }
+        catch (error) {
+            if (error instanceof BusinessException) {
+                throw new KnownException(`Failed to create ephemeral environment: ${error.message}`);
+            }
+            throw error;
+        }
+        return toUrl(`/public/env/${env.key}/extend?token=${result.token}`);
     }
     async create(env) {
-        const { ttl } = await this.httpClient.post('/ci/env', env);
-        return { ...env, ephemeral: false, status: EnvStatus.Deploying, ttl };
+        let result;
+        try {
+            result = await this.httpClient.post('/ci/env', env);
+        }
+        catch (error) {
+            if (error instanceof BusinessException) {
+                throw new KnownException(`Failed to create environment: ${error.message}`);
+            }
+            throw error;
+        }
+        return { ...env, ephemeral: false, status: EnvStatus.Deploying, ttl: result.ttl };
     }
     async setVars(env, vars) {
-        await this.httpClient.post(`/ci/env/${env.key}/vars`, vars);
+        try {
+            await this.httpClient.post(`/ci/env/${env.key}/vars`, vars);
+        }
+        catch (error) {
+            if (error instanceof BusinessException) {
+                throw new KnownException(`Failed to set vars for environment ${env.key}: ${error.message}`);
+            }
+            throw error;
+        }
         env.vars = { ...env.vars || {}, ...vars };
     }
     async activate(env) {
-        await this.httpClient.post(`/ci/env/${env.key}/activate`);
+        try {
+            await this.httpClient.post(`/ci/env/${env.key}/activate`);
+        }
+        catch (error) {
+            if (error instanceof BusinessException) {
+                throw new KnownException(`Failed to activate environment ${env.key}: ${error.message}`);
+            }
+            throw error;
+        }
         env.status = EnvStatus.Active;
     }
     async lockForUpdate(env) {
@@ -38,25 +72,33 @@ export class EnvApiClient {
             stateFile: env.stateFile,
             lockFile: env.lockFile
         };
-        const { status } = await this.httpClient.post(`/ci/env/${env.key}/lock-for-update`, body);
-        env.status = status;
+        let result;
+        try {
+            result = await this.httpClient.post(`/ci/env/${env.key}/lock-for-update`, body);
+        }
+        catch (error) {
+            if (error instanceof BusinessException) {
+                throw new KnownException(`Failed to lock environment ${env.key} for update: ${error.message}`);
+            }
+            throw error;
+        }
+        env.status = result.status;
     }
-    async delete(env) {
+    async delete(key, force = false) {
         console.log('Sending delete command');
         let result;
         try {
-            result = await this.httpClient.fetch(`/ci/env/${env.key}`, {
+            result = await this.httpClient.fetch(`/ci/env/${key}?force=${force}`, {
                 method: 'DELETE'
             });
         }
         catch (error) {
             if (error instanceof NotFoundException) {
-                throw new KnownException(`Environment ${env.key} is not found`);
+                throw new KnownException(`Environment ${key} is not found`);
             }
             throw error;
         }
-        env.status = EnvStatus.Deleting;
-        console.log(result.statusText);
+        console.log(result.message);
     }
     async getLogs(key) {
         let result;

package/dist/client/HttpClient.js

@@ -1,5 +1,8 @@
 import { BusinessException, HttpException, NotFoundException } from '../exceptions.js';
 const HOST = 'cli.maintenance.agilecustoms.com';
+export function toUrl(path) {
+    return `https://${HOST}/env-api${path}`;
+}
 export class HttpClient {
     constructor() { }
     async post(path, body, options = {}) {
@@ -15,7 +18,7 @@ export class HttpClient {
         return await this.fetch(path, options);
     }
     async fetch(path, options = {}) {
-        const url = `https://${HOST}/env-api${path}`;
+        const url = toUrl(path);
         let response;
         try {
             response = await fetch(url, options);

package/dist/client/TerraformAdapter.js

@@ -1,6 +1,8 @@
 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 = [
     'ConcurrentModificationException',
@@ -8,14 +10,17 @@ const RETRYABLE_ERRORS = [
     'operation error Lambda: AddPermission, https response error StatusCode: 404',
     `because public policies are prevented by the BlockPublicPolicy setting in S3 Block Public Access`
 ];
+function hash(data) {
+    return createHash('sha256').update(data).digest('hex');
+}
 export class TerraformAdapter {
-    processRunner;
-    cliHelper;
+    cli;
+    localStateService;
     backends;
     backend = undefined;
-    constructor(processRunner, cliHelper, backends) {
-        this.processRunner = processRunner;
-        this.cliHelper = cliHelper;
+    constructor(cli, localStateService, backends) {
+        this.cli = cli;
+        this.localStateService = localStateService;
         this.backends = backends.reduce((acc, backend) => {
             acc.set(backend.getType(), backend);
             return acc;
@@ -34,13 +39,6 @@ export class TerraformAdapter {
             throw new KnownException(`Failed to read terraform lock file: ${lockPath}`, { cause: err });
         }
     }
-    getKey(key, cwd) {
-        if (!key) {
-            console.log('Key is not provided, inferring from state file');
-            key = this.getTerraformBackend(cwd).getKey();
-        }
-        return key;
-    }
     getTerraformBackend(cwd) {
         if (this.backend) {
             return this.backend;
@@ -75,9 +73,37 @@ export class TerraformAdapter {
         this.backend = backend;
         return backend;
     }
+    async lock(newEnv, cwd) {
+        const res = {};
+        const stateFileContent = this.getTerraformBackend(cwd).validateAndGetStateFileContent();
+        const stateHash = hash(stateFileContent);
+        const config = this.localStateService.load(cwd);
+        if (config.stateHash !== stateHash || newEnv) {
+            config.stateHash = stateHash;
+            res.stateFile = stateFileContent;
+        }
+        const linuxArm64 = process.platform === 'linux' && process.arch === 'arm64';
+        if (!linuxArm64 || newEnv) {
+            let lockFileContent = this.getLockFile(cwd);
+            if (!linuxArm64) {
+                const lockFileHash = hash(lockFileContent);
+                if (config.lockHash !== lockFileHash) {
+                    await this.lockProviders(cwd);
+                    lockFileContent = this.getLockFile(cwd);
+                    config.lockHash = hash(lockFileContent);
+                    res.lockFile = lockFileContent;
+                }
+            }
+            if (newEnv) {
+                res.lockFile = lockFileContent;
+            }
+        }
+        this.localStateService.save(config, cwd);
+        return res;
+    }
     async lockProviders(cwd) {
         console.log('Update lock file');
-        await this.processRunner.run('terraform', ['providers', 'lock', '-platform=linux_arm64'], cwd);
+        await this.cli.run('terraform', ['providers', 'lock', '-platform=linux_arm64'], cwd);
     }
     printTime() {
         const now = new Date();
@@ -168,7 +194,7 @@ export class TerraformAdapter {
         const args = this.tfArgs(env, cwd);
         console.log('Running: terraform plan -auto-approve', ...args, '\n');
         try {
-            await this.processRunner.run('terraform', ['plan', ...args], cwd);
+            await this.cli.run('terraform', ['plan', ...args], cwd);
         }
         catch (error) {
             if (!(error instanceof ProcessException)) {
@@ -210,7 +236,7 @@ export class TerraformAdapter {
         console.log('Running: terraform apply -auto-approve', ...args, '\n');
         this.printTime();
         try {
-            await this.processRunner.run('terraform', ['apply', '-auto-approve', ...args], cwd, out_scanner, in_scanner);
+            await this.cli.run('terraform', ['apply', '-auto-approve', ...args], cwd, out_scanner, in_scanner);
             this.printTime();
         }
         catch (error) {
@@ -240,7 +266,7 @@ export class TerraformAdapter {
         const args = this.tfArgs(env, cwd);
         console.log('Running: terraform destroy -auto-approve', ...args, '\n');
         try {
-            await this.processRunner.run('terraform', ['destroy', '-auto-approve', ...args], cwd, scanner);
+            await this.cli.run('terraform', ['destroy', '-auto-approve', ...args], cwd, scanner);
         }
         catch (error) {
             if (!(error instanceof ProcessException)) {
@@ -273,7 +299,7 @@ export class TerraformAdapter {
         }
     }
     async promptUnlock(id, cwd) {
-        const answerYes = await this.cliHelper.promptYesNo('Terraform state is locked. Most often due to previously interrupted process.\n'
+        const answerYes = await this.cli.promptYesNo('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?: ');
         if (!answerYes) {
@@ -283,6 +309,6 @@ export class TerraformAdapter {
     }
     async forceUnlock(id, cwd) {
         console.log('Force unlocking state');
-        await this.processRunner.run('terraform', ['force-unlock', '-force', id], cwd);
+        await this.cli.run('terraform', ['force-unlock', '-force', id], cwd);
     }
 }

package/dist/client/index.js

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

package/dist/commands/_utils.js

@@ -1,5 +1,5 @@
 import { ExitPromptError } from '@inquirer/core';
-import { BusinessException, AbortedException, KnownException } from '../exceptions.js';
+import { AbortedException, KnownException } from '../exceptions.js';
 export function wrap(callable) {
     return async (...args) => {
         let result;
@@ -7,7 +7,7 @@ export function wrap(callable) {
             result = await callable(...args);
         }
         catch (error) {
-            if (error instanceof KnownException || error instanceof BusinessException) {
+            if (error instanceof KnownException) {
                 console.error(error.message);
             }
             else if (error instanceof AbortedException || error instanceof ExitPromptError) {

package/dist/container.js

@@ -1,19 +1,18 @@
 import { S3Backend } from './backend/S3Backend.js';
-import { CliHelper, EnvApiClient, HttpClient, TerraformAdapter } from './client/index.js';
-import { ProcessRunner } from './client/ProcessRunner.js';
+import { Cli } from './client/Cli.js';
+import { EnvApiClient, HttpClient, TerraformAdapter } from './client/index.js';
 import { ConfigService, EnvService } from './service/index.js';
 import { LocalStateService } from './service/LocalStateService.js';
 import { LogService } from './service/LogService.js';
-const cliHelper = new CliHelper();
+const cli = new Cli();
 const configService = new ConfigService();
 const backends = [
     new S3Backend()
 ];
 const httpClient = new HttpClient();
 const envApiClient = new EnvApiClient(httpClient);
-const processRunner = new ProcessRunner();
-const terraformAdapter = new TerraformAdapter(processRunner, cliHelper, backends);
 const localStateService = new LocalStateService();
-const envService = new EnvService(cliHelper, envApiClient, terraformAdapter, localStateService);
-const logService = new LogService(envApiClient, terraformAdapter, processRunner);
+const terraformAdapter = new TerraformAdapter(cli, localStateService, backends);
+const envService = new EnvService(cli, envApiClient, terraformAdapter);
+const logService = new LogService(cli, envApiClient, terraformAdapter);
 export { configService, envService, logService };

package/dist/service/BaseService.js

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

package/dist/service/EnvService.js

@@ -1,20 +1,18 @@
-import { CliHelper, EnvApiClient, TerraformAdapter } from '../client/index.js';
+import { Cli } from '../client/Cli.js';
+import { EnvApiClient, TerraformAdapter } from '../client/index.js';
 import { KnownException } from '../exceptions.js';
 import { EnvStatus } from '../model/index.js';
-import { LocalStateService } from './LocalStateService.js';
-export class EnvService {
-    cliHelper;
+import { BaseService } from './BaseService.js';
+export class EnvService extends BaseService {
+    cli;
     envApi;
-    terraformAdapter;
-    localStateService;
-    constructor(cliHelper, envApi, terraformAdapter, localStateService) {
-        this.cliHelper = cliHelper;
+    constructor(cli, envApi, terraformAdapter) {
+        super(terraformAdapter);
+        this.cli = cli;
         this.envApi = envApi;
-        this.terraformAdapter = terraformAdapter;
-        this.localStateService = localStateService;
     }
     async status(key, cwd) {
-        key = this.terraformAdapter.getKey(key, cwd);
+        key = this.getKey(key, cwd);
         console.log(`Retrieve env ${key}`);
         const env = await this.envApi.get(key);
         if (env === null) {
@@ -35,7 +33,7 @@ export class EnvService {
             console.log(`Expires at ${formattedDate}`);
         }
         if (env.kind) {
-            const kind = this.cliHelper.getKind(cwd);
+            const kind = this.cli.getKind(cwd);
             if (env.kind !== kind) {
                 console.warn(`Env ${key} kind (dir-name): ${env.kind} - looks like this env was deployed from a different directory`);
             }
@@ -56,7 +54,7 @@ export class EnvService {
         if (env.ephemeral)
             return;
         if (env.kind) {
-            const kind = this.cliHelper.getKind(cwd);
+            const kind = this.cli.getKind(cwd);
             if (kind !== env.kind) {
                 throw new KnownException(`Env ${env.key} kind (dir-name): ${env.kind} - make sure you run this command from the same directory`);
             }
@@ -77,46 +75,24 @@ export class EnvService {
         await this.terraformAdapter.plan(envTerraform, cwd);
     }
     async createEphemeral(key) {
-        const env = await this.envApi.get(key);
-        if (env !== null) {
-            throw new KnownException(`Env ${key} already exists`);
-        }
         const createEnv = { key };
         return await this.envApi.createEphemeral(createEnv);
     }
     async lockTerraform(env, cwd, newEnv = false) {
-        const config = this.localStateService.load(cwd);
         console.log('Validate terraform.tfstate file');
-        const stateFileContent = this.terraformAdapter.getTerraformBackend(cwd).validateAndGetStateFileContent();
-        const stateHash = this.localStateService.hash(stateFileContent);
-        if (config.stateHash !== stateHash || newEnv) {
-            config.stateHash = stateHash;
-            env.stateFile = stateFileContent;
-        }
-        const linuxArm64 = process.platform === 'linux' && process.arch === 'arm64';
-        if (!linuxArm64 || newEnv) {
-            let lockFileContent = this.terraformAdapter.getLockFile(cwd);
-            if (!linuxArm64) {
-                const lockFileHash = this.localStateService.hash(lockFileContent);
-                if (config.lockHash !== lockFileHash) {
-                    await this.terraformAdapter.lockProviders(cwd);
-                    lockFileContent = this.terraformAdapter.getLockFile(cwd);
-                    config.lockHash = this.localStateService.hash(lockFileContent);
-                    env.lockFile = lockFileContent;
-                }
-            }
-            if (newEnv) {
-                env.lockFile = lockFileContent;
-            }
+        const res = await this.terraformAdapter.lock(newEnv, cwd);
+        if (res.lockFile) {
+            env.lockFile = res.lockFile;
+        }
+        if (res.stateFile) {
+            env.stateFile = res.stateFile;
         }
-        this.localStateService.save(config, cwd);
     }
     async deploy(tfArgs, cwd) {
         const key = this.terraformAdapter.getTerraformBackend(cwd).getKey();
         let env = await this.tryGetEnv(key);
         if (env === null) {
-            this.localStateService.init(cwd);
-            const kind = this.cliHelper.getKind(cwd);
+            const kind = this.cli.getKind(cwd);
             console.log(`Inferred kind from directory name: ${kind}`);
             const createEnv = { key, kind };
             await this.lockTerraform(createEnv, cwd, true);
@@ -128,12 +104,8 @@ export class EnvService {
         this.checkKind(env, cwd);
         switch (env.status) {
             case EnvStatus.Init:
-                this.localStateService.init(cwd);
-                await this.lockTerraform(env, cwd, true);
-                await this.envApi.lockForUpdate(env);
-                break;
             case EnvStatus.Active:
-                if (env.status === EnvStatus.Active) {
+                if (env.status == EnvStatus.Active) {
                     console.log('Env status is ACTIVE\nWill lock for update and run terraform apply (to update resources)');
                 }
                 await this.lockTerraform(env, cwd);
@@ -141,7 +113,7 @@ export class EnvService {
                 break;
             case EnvStatus.Deploying:
             case EnvStatus.Updating:
-                const answerYes = await this.cliHelper.promptYesNo(`Env status is ${env.status}, likely due to an error from a previous run\n
+                const answerYes = await this.cli.promptYesNo(`Env status is ${env.status}, likely due to an error from a previous run\n
           Do you want to proceed with deployment?`);
                 if (!answerYes) {
                     console.log('Aborting deployment');
@@ -173,44 +145,19 @@ export class EnvService {
         await this.envApi.activate(env);
     }
     async delete(force, key, cwd) {
-        key = this.terraformAdapter.getKey(key, cwd);
-        const env = await this.get(key);
-        if (env.status === EnvStatus.Init) {
-            await this.envApi.delete(env);
-            return;
-        }
-        if (force) {
-            await this.envApi.delete(env);
-            return;
-        }
-        if (env.status === EnvStatus.Deleting) {
-            throw new KnownException(`Env ${env.key} status is DELETING, please wait or re-run with --force`);
-        }
-        const kind = this.cliHelper.getKind(cwd);
-        if (env.kind && env.kind !== kind) {
-            const answerYes = await this.cliHelper.promptYesNo(`Env ${env.key} kind (dir-name): ${env.kind}\n`
-                + 'You\'re deleting env deployed from different dir\n'
-                + 'Do you want to proceed?');
-            if (!answerYes) {
-                console.log('Aborting deletion');
-                return;
-            }
-        }
-        await this.envApi.delete(env);
+        key = this.getKey(key, cwd);
+        await this.envApi.delete(key, force);
     }
     async destroy(tfArgs, force, cwd) {
         const key = this.terraformAdapter.getTerraformBackend(cwd).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`);
-            await this.envApi.delete(env);
+            await this.envApi.delete(key, force);
             return;
         }
-        if (!force) {
-            if (env.status === EnvStatus.Deleting) {
-                throw new KnownException(`Env ${env.key} status is DELETING, please wait or re-run with --force`);
-            }
-            this.checkKind(env, cwd);
+        if (env.status === EnvStatus.Deleting && !force) {
+            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');
@@ -219,14 +166,14 @@ export class EnvService {
         const { ephemeral, vars } = env;
         const envTerraform = { key, ephemeral, args: tfArgs, vars };
         await this.terraformAdapter.destroy(envTerraform, force, cwd);
-        await this.envApi.delete(env);
+        await this.envApi.delete(key, force);
         console.log('Please wait for ~30 sec before you can create env with same name');
     }
     async get(key) {
         console.log(`Retrieve env ${key}`);
         const env = await this.envApi.get(key);
         if (!env) {
-            throw new KnownException(`Environment ${key} does not exist`);
+            throw new KnownException(`Environment ${key} is not found`);
         }
         console.log(`Env status: ${env.status}`);
         return env;

package/dist/service/LocalStateService.js

@@ -1,42 +1,22 @@
-import { createHash } from 'node:crypto';
 import * as fs from 'node:fs';
 import path from 'path';
 const CURRENT_VERSION = 1;
 export class LocalStateService {
     config;
-    constructor() {
-    }
     filePath(cwd) {
         cwd = cwd || process.cwd();
         return path.join(cwd, '.terraform', 'envctl.json');
     }
-    hash(data) {
-        return createHash('sha256').update(data).digest('hex');
-    }
     createEmptyConfig(filePath) {
         fs.mkdirSync(path.dirname(filePath), { recursive: true });
         this.config = { version: CURRENT_VERSION };
         fs.writeFileSync(filePath, JSON.stringify(this.config, null, 2));
         return this.config;
     }
-    init(cwd) {
-        const filePath = this.filePath(cwd);
-        if (!fs.existsSync(filePath)) {
-            this.createEmptyConfig(filePath);
-            return;
-        }
-        const data = fs.readFileSync(filePath, 'utf-8');
-        const config = JSON.parse(data);
-        if (config.version == CURRENT_VERSION) {
-            this.config = config;
-            return;
-        }
-        console.log('Local state file version mismatch, re-initializing');
-        this.createEmptyConfig(filePath);
-    }
     load(cwd) {
-        if (this.config)
+        if (this.config) {
             return this.config;
+        }
         console.log('Load local state config');
         const filePath = this.filePath(cwd);
         if (!fs.existsSync(filePath)) {
@@ -44,8 +24,13 @@ export class LocalStateService {
             return this.createEmptyConfig(filePath);
         }
         const data = fs.readFileSync(filePath, 'utf-8');
-        this.config = JSON.parse(data);
-        return this.config;
+        let config = JSON.parse(data);
+        if (config.version != CURRENT_VERSION) {
+            console.log('Local state file version mismatch, re-initializing');
+            config = this.createEmptyConfig(filePath);
+        }
+        this.config = config;
+        return config;
     }
     save(config, cwd) {
         if (!this.config) {

package/dist/service/LogService.js

@@ -6,17 +6,17 @@ import { Readable } from 'node:stream';
 import { pipeline } from 'node:stream/promises';
 import { TerraformAdapter } from '../client/index.js';
 import { KnownException } from '../exceptions.js';
-export class LogService {
+import { BaseService } from './BaseService.js';
+export class LogService extends BaseService {
+    cli;
     envApi;
-    terraformAdapter;
-    processRunner;
-    constructor(envApi, terraformAdapter, processRunner) {
+    constructor(cli, envApi, terraformAdapter) {
+        super(terraformAdapter);
+        this.cli = cli;
         this.envApi = envApi;
-        this.terraformAdapter = terraformAdapter;
-        this.processRunner = processRunner;
     }
     async getLogs(key, cwd) {
-        key = this.terraformAdapter.getKey(key, cwd);
+        key = this.getKey(key, cwd);
         const url = await this.envApi.getLogs(key);
         const urlPath = new URL(url).pathname;
         const gzName = basename(urlPath);
@@ -42,6 +42,6 @@ export class LogService {
         }
         await pipeline(Readable.fromWeb(res.body), createWriteStream(outPath, { flags: 'w' }));
         console.log(`Logs saved to: ${outPath}`);
-        await this.processRunner.run('open', ['-R', outPath]);
+        await this.cli.run('open', ['-R', outPath]);
     }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agilecustoms/envctl",
   "description": "node.js CLI client for manage environments",
-  "version": "1.1.1",
+  "version": "1.3.0",
   "author": "Alex Chekulaev",
   "type": "module",
   "engines": {
@@ -26,32 +26,34 @@
     "lint": "eslint *.{ts,mjs} \"src/**/*.ts\" \"test/**/*.ts\"",
     "lint:fix": "npm run lint -- --fix",
     "test": "vitest run --coverage",
-    "build": "tsc",
-    "run": "node dist/index.js",
-    "run-version": "  tsc --sourceMap true && npm run run -- --version",
-    "run-configure": "tsc --sourceMap true && npm run run -- configure",
+    "build": "tsc -p tsconfig.build.json",
+    "run": "tsc -p tsconfig.build.json --sourceMap true && node dist/index.js",
+    "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": " tsc --sourceMap true && npm run run -- status  --cwd ../tt-core",
-    "run-core-plan": "   tsc --sourceMap true && npm run run -- plan    --cwd ../tt-core",
-    "run-core-deploy": " tsc --sourceMap true && npm run run -- deploy  --cwd ../tt-core -var=\"env_size=min\"",
-    "run-core-delete": " tsc --sourceMap true && npm run run -- delete  --cwd ../tt-core",
-    "run-core-destroy": "tsc --sourceMap true && npm run run -- destroy --cwd ../tt-core",
-    "run-core-logs": "   tsc --sourceMap true && npm run run -- logs    --cwd ../tt-core",
+    "run-core-init": "  cd ../tt-core && terraform init -upgrade -backend-config=key=laxa1986 -reconfigure",
+    "run-core-tfplan": "cd ../tt-core && terraform plan -out=.terraform/plan",
+    "run-core-status": " npm run run -- status  --cwd ../tt-core",
+    "run-core-plan": "   npm run run -- plan    --cwd ../tt-core",
+    "run-core-deploy": " npm run run -- deploy  --cwd ../tt-core -var=\"env_size=min\"",
+    "run-core-deployp": "npm run run -- deploy .terraform/plan --cwd ../tt-core",
+    "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-init": "cd ../tt-gitops && terraform init -upgrade -backend-config=key=laxa1986 -reconfigure",
-    "run-status": " tsc --sourceMap true &&                                 npm run run -- status  --cwd ../tt-gitops",
-    "run-plan": "   tsc --sourceMap true && AWS_PROFILE=ac-tt-dev-deployer  npm run run -- plan    --cwd ../tt-gitops -var=\"env_size=min\" -var-file=versions.tfvars",
-    "run-deploy": " tsc --sourceMap true && AWS_PROFILE=ac-tt-dev-deployer  npm run run -- deploy  --cwd ../tt-gitops -var=\"env_size=min\" -var-file=versions.tfvars",
-    "run-delete": " tsc --sourceMap true &&                                 npm run run -- delete  --cwd ../tt-gitops",
-    "run-destroy": "tsc --sourceMap true && AWS_PROFILE=ac-tt-dev-destroyer npm run run -- destroy --cwd ../tt-gitops -var=\"env_size=min\" -var-file=versions.tfvars",
+    "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-ephemeral-create": " tsc --sourceMap true && npm run run -- create-ephemeral --key test",
+    "run-ephemeral-create": " npm run run -- create-ephemeral --key test",
     "run-ephemeral-init": "cd ../tt-gitops && terraform init -upgrade -backend-config=key=test -reconfigure",
-    "run-ephemeral-status": " tsc --sourceMap true && npm run run -- status --key test",
-    "run-ephemeral-deploy": " tsc --sourceMap true && npm run run -- deploy  --cwd ../tt-gitops -var-file=versions.tfvars",
-    "run-ephemeral-delete": " tsc --sourceMap true && npm run run -- delete  --cwd ../tt-gitops --force",
-    "run-ephemeral-destroy": "tsc --sourceMap true && npm run run -- destroy --cwd ../tt-gitops --force -var-file=versions.tfvars"
+    "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"
   },
   "dependencies": {
     "commander": "^14.0.0",

package/dist/client/CliHelper.js

@@ -1,30 +0,0 @@
-import path from 'path';
-import inquirer from 'inquirer';
-export class CliHelper {
-    constructor() { }
-    async promptYesNo(message, defaultValue = false) {
-        const { answer } = await inquirer.prompt([{
-                type: 'confirm',
-                name: 'answer',
-                message,
-                default: defaultValue,
-            }]);
-        return answer;
-    }
-    getKind(cwd) {
-        return getDirName(cwd);
-    }
-}
-function getDirName(cwd) {
-    cwd = resolveCwd(cwd);
-    return path.basename(cwd);
-}
-function resolveCwd(cwd) {
-    if (!cwd) {
-        return process.cwd();
-    }
-    if (path.isAbsolute(cwd)) {
-        return cwd;
-    }
-    return path.resolve(process.cwd(), cwd);
-}