@agilecustoms/envctl 1.3.1 → 1.4.0

package/dist/client/Cli.js

@@ -9,27 +9,11 @@ import path from 'path';
 import * as readline from 'readline';
 import inquirer from 'inquirer';
 import { ProcessException } from '../exceptions.js';
-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) {
+    async run(command, args, out_scanner, in_scanner) {
         const spawnOptions = {
             stdio: ['pipe', 'pipe', 'pipe'],
         };
-        if (cwd) {
-            spawnOptions.cwd = cwd;
-        }
         const child = spawn(command, args, spawnOptions);
         child.stdout.setEncoding('utf8');
         child.stderr.setEncoding('utf8');
@@ -98,8 +82,8 @@ export class Cli {
             }]);
         return answer;
     }
-    getKind(cwd) {
-        return getDirName(cwd);
+    getKind() {
+        return path.basename(process.cwd());
     }
     async writeInTmpFile(stream, fileName) {
         const outDir = join(tmpdir(), 'envctl');

package/dist/client/EnvApiClient.js

@@ -46,18 +46,6 @@ export class EnvApiClient {
         }
         return { ...env, ephemeral: false, status: EnvStatus.Deploying, ttl: result.ttl };
     }
-    async setVars(env, 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) {
         try {
             await this.httpClient.post(`/ci/env/${env.key}/activate`);

package/dist/client/TerraformAdapter.js

@@ -26,9 +26,8 @@ export class TerraformAdapter {
             return acc;
         }, new Map());
     }
-    getLockFile(cwd) {
-        const dir = cwd ?? process.cwd();
-        const lockPath = path.join(dir, '.terraform.lock.hcl');
+    getLockFile() {
+        const lockPath = path.join(process.cwd(), '.terraform.lock.hcl');
         if (!fs.existsSync(lockPath)) {
             throw new KnownException(`Terraform lock file not found at: ${lockPath}`);
         }
@@ -39,12 +38,11 @@ export class TerraformAdapter {
             throw new KnownException(`Failed to read terraform lock file: ${lockPath}`, { cause: err });
         }
     }
-    getTerraformBackend(cwd) {
+    getTerraformBackend() {
         if (this.backend) {
             return this.backend;
         }
-        const dir = cwd ?? process.cwd();
-        const statePath = path.join(dir, '.terraform', 'terraform.tfstate');
+        const statePath = path.join(process.cwd(), '.terraform', 'terraform.tfstate');
         if (!fs.existsSync(statePath)) {
             throw new KnownException(`Terraform state file not found at: ${statePath}`);
         }
@@ -73,23 +71,23 @@ export class TerraformAdapter {
         this.backend = backend;
         return backend;
     }
-    async lock(newEnv, cwd) {
+    async lock(newEnv) {
         const res = {};
-        const stateFileContent = this.getTerraformBackend(cwd).validateAndGetStateFileContent();
+        const stateFileContent = this.getTerraformBackend().validateAndGetStateFileContent();
         const stateHash = hash(stateFileContent);
-        const config = this.localStateService.load(cwd);
+        const config = this.localStateService.load();
         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);
+            let lockFileContent = this.getLockFile();
             if (!linuxArm64) {
                 const lockFileHash = hash(lockFileContent);
                 if (config.lockHash !== lockFileHash) {
-                    await this.lockProviders(cwd);
-                    lockFileContent = this.getLockFile(cwd);
+                    await this.lockProviders();
+                    lockFileContent = this.getLockFile();
                     config.lockHash = hash(lockFileContent);
                     res.lockFile = lockFileContent;
                 }
@@ -98,12 +96,12 @@ export class TerraformAdapter {
                 res.lockFile = lockFileContent;
             }
         }
-        this.localStateService.save(config, cwd);
+        this.localStateService.save(config);
         return res;
     }
-    async lockProviders(cwd) {
+    async lockProviders() {
         console.log('Update lock file');
-        await this.cli.run('terraform', ['providers', 'lock', '-platform=linux_arm64'], cwd);
+        await this.cli.run('terraform', ['providers', 'lock', '-platform=linux_arm64']);
     }
     printTime() {
         const now = new Date();
@@ -113,9 +111,9 @@ export class TerraformAdapter {
         });
         console.log(`\nTime EDT: ${edt},  UTC: ${utc}\n`);
     }
-    tfArgs(env, cwd) {
-        const varDefs = this.getVarDefs(cwd);
-        const argVars = this.getArgVars(env.args);
+    tfArgs(env, args, vars = []) {
+        const varDefs = this.getVarDefs();
+        const argVars = this.getArgVars(args);
         const specialFields = { ...env, env: env.key };
         const extraArgs = [];
         for (const name of ['env', 'owner', 'ephemeral']) {
@@ -123,15 +121,15 @@ export class TerraformAdapter {
                 extraArgs.push('-var=' + name + '=' + specialFields[name]);
             }
         }
-        Object.entries(env.vars || {}).forEach(([key, value]) => {
+        Object.entries(vars || {}).forEach(([key, value]) => {
             if (varDefs[key] && !argVars[key]) {
                 extraArgs.push('-var=' + key + '=' + value);
             }
         });
-        return [...extraArgs, ...env.args];
+        return [...extraArgs, ...args];
     }
-    getVarDefs(cwd) {
-        const dir = cwd ?? process.cwd();
+    getVarDefs() {
+        const dir = process.cwd();
         const tfFiles = fs.readdirSync(dir)
             .filter(file => file.endsWith('.tf'))
             .map(file => path.join(dir, file));
@@ -170,10 +168,9 @@ export class TerraformAdapter {
         });
         return result;
     }
-    getNewVars(envTerraform, onDemandVars, cwd) {
-        const varDefs = this.getVarDefs(cwd);
-        const argVars = this.getArgVars(envTerraform.args);
-        const envVars = envTerraform.vars;
+    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]) => {
@@ -190,30 +187,13 @@ export class TerraformAdapter {
         });
         return newVars;
     }
-    async plan(env, cwd, attemptNo = 1) {
-        const args = this.tfArgs(env, cwd);
-        console.log('Running: terraform plan -auto-approve', ...args, '\n');
-        try {
-            await this.cli.run('terraform', ['plan', ...args], cwd);
-        }
-        catch (error) {
-            if (!(error instanceof ProcessException)) {
-                throw error;
-            }
-            if (attemptNo < MAX_ATTEMPTS && RETRYABLE_ERRORS.some(err => error.message.includes(err))) {
-                console.warn(`Retrying terraform plan due to error: ${error.message}`);
-                return this.plan(env, cwd, attemptNo + 1);
-            }
-            const lockId = this.lockId(error, attemptNo);
-            if (lockId) {
-                await this.promptUnlock(lockId, cwd);
-                console.info('State unlocked, retrying terraform plan');
-                return this.plan(env, cwd, attemptNo + 1);
-            }
-            throw new KnownException(`terraform plan failed with code ${error.code}:\n${error.message}`, { cause: error });
+    async plan(env, args, onDemandVars = {}) {
+        if (env) {
+            args = this.tfArgs(env, args);
         }
+        await this._plan(args, onDemandVars);
     }
-    async apply(env, onDemandVars, cwd, attemptNo = 1) {
+    async _plan(args, onDemandVars, attemptNo = 1) {
         let inputTfVariable = false;
         let tfVarName = '';
         function out_scanner(line) {
@@ -232,11 +212,32 @@ export class TerraformAdapter {
                 tfVarName = '';
             }
         }
-        const args = this.tfArgs(env, cwd);
-        console.log('Running: terraform apply -auto-approve', ...args, '\n');
+        console.log('Running: terraform plan -auto-approve', ...args, '\n');
+        try {
+            await this.cli.run('terraform', ['plan', ...args], out_scanner, in_scanner);
+        }
+        catch (error) {
+            if (!(error instanceof ProcessException)) {
+                throw error;
+            }
+            if (attemptNo < MAX_ATTEMPTS && RETRYABLE_ERRORS.some(err => error.message.includes(err))) {
+                console.warn(`Retrying terraform plan due to error: ${error.message}`);
+                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');
+                return this._plan(args, onDemandVars, attemptNo + 1);
+            }
+            throw new KnownException(`terraform plan failed with code ${error.code}:\n${error.message}`, { cause: error });
+        }
+    }
+    async apply(args, attemptNo = 1) {
+        console.log('Running: terraform apply ', ...args, '\n');
         this.printTime();
         try {
-            await this.cli.run('terraform', ['apply', '-auto-approve', ...args], cwd, out_scanner, in_scanner);
+            await this.cli.run('terraform', ['apply', ...args]);
             this.printTime();
         }
         catch (error) {
@@ -245,28 +246,31 @@ export class TerraformAdapter {
             }
             if (attemptNo < MAX_ATTEMPTS && RETRYABLE_ERRORS.some(err => error.message.includes(err))) {
                 console.warn(`Retrying terraform apply due to error: ${error.message}`);
-                return this.apply(env, onDemandVars, cwd, attemptNo + 1);
+                return this.apply(args, attemptNo + 1);
             }
             const lockId = this.lockId(error, attemptNo);
             if (lockId) {
-                await this.promptUnlock(lockId, cwd);
+                await this.promptUnlock(lockId);
                 console.info('State unlocked, retrying terraform apply');
-                return this.apply(env, onDemandVars, cwd, attemptNo + 1);
+                return this.apply(args, attemptNo + 1);
             }
             throw new KnownException(`terraform apply failed with code ${error.code}:\n${error.message}`, { cause: error });
         }
     }
-    async destroy(env, force, cwd, attemptNo = 1) {
+    async destroy(env, args, force) {
+        args = this.tfArgs(env, args);
+        await this._destroy(args, force);
+    }
+    async _destroy(args, force, attemptNo = 1) {
         let wrongDir = false;
         const scanner = (line) => {
             if (line.includes('Either you have not created any objects yet or the existing objects were')) {
                 wrongDir = true;
             }
         };
-        const args = this.tfArgs(env, cwd);
         console.log('Running: terraform destroy -auto-approve', ...args, '\n');
         try {
-            await this.cli.run('terraform', ['destroy', '-auto-approve', ...args], cwd, scanner);
+            await this.cli.run('terraform', ['destroy', '-auto-approve', ...args], scanner);
         }
         catch (error) {
             if (!(error instanceof ProcessException)) {
@@ -275,13 +279,13 @@ export class TerraformAdapter {
             const lockId = this.lockId(error, attemptNo);
             if (lockId) {
                 if (force) {
-                    await this.forceUnlock(lockId, cwd);
+                    await this.forceUnlock(lockId);
                 }
                 else {
-                    await this.promptUnlock(lockId, cwd);
+                    await this.promptUnlock(lockId);
                 }
                 console.info('State unlocked, retrying terraform destroy');
-                return this.destroy(env, force, cwd, attemptNo + 1);
+                return this._destroy(args, force, attemptNo + 1);
             }
             throw new KnownException(`terraform destroy failed with code ${error.code}:\n${error.message}`, { cause: error });
         }
@@ -298,17 +302,17 @@ export class TerraformAdapter {
             }
         }
     }
-    async promptUnlock(id, cwd) {
+    async promptUnlock(id) {
         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) {
             throw new AbortedException();
         }
-        await this.forceUnlock(id, cwd);
+        await this.forceUnlock(id);
     }
-    async forceUnlock(id, cwd) {
+    async forceUnlock(id) {
         console.log('Force unlocking state');
-        await this.cli.run('terraform', ['force-unlock', '-force', id], cwd);
+        await this.cli.run('terraform', ['force-unlock', '-force', id]);
     }
 }

package/dist/commands/delete.js

@@ -13,5 +13,7 @@ export function deleteIt(program) {
 }
 async function handler(options) {
     const { key, force, cwd } = options;
-    await envService.delete(Boolean(force), key, cwd);
+    if (cwd)
+        process.chdir(cwd);
+    await envService.delete(Boolean(force), key);
 }

package/dist/commands/deploy.js

@@ -13,5 +13,7 @@ export function deploy(program) {
 }
 async function handler(tfArgs, options) {
     const { cwd } = options;
-    await envService.deploy(tfArgs, cwd);
+    if (cwd)
+        process.chdir(cwd);
+    await envService.deploy(tfArgs);
 }

package/dist/commands/destroy.js

@@ -17,5 +17,7 @@ export function destroy(program) {
 }
 async function handler(tfArgs, options) {
     const { force, cwd } = options;
-    await envService.destroy(tfArgs, Boolean(force), cwd);
+    if (cwd)
+        process.chdir(cwd);
+    await envService.destroy(tfArgs, Boolean(force));
 }

package/dist/commands/logs.js

@@ -12,5 +12,7 @@ export function logs(program) {
 }
 async function handler(options) {
     const { key, cwd } = options;
-    await logService.getLogs(key, cwd);
+    if (cwd)
+        process.chdir(cwd);
+    await logService.getLogs(key);
 }

package/dist/commands/plan.js

@@ -14,5 +14,7 @@ export function plan(program) {
 }
 async function handler(tfArgs, options) {
     const { cwd } = options;
-    await envService.plan(tfArgs, cwd);
+    if (cwd)
+        process.chdir(cwd);
+    await envService.plan(tfArgs);
 }

package/dist/commands/status.js

@@ -12,5 +12,7 @@ export function status(program) {
 }
 async function handler(options) {
     const { key, cwd } = options;
-    await envService.status(key, cwd);
+    if (cwd)
+        process.chdir(cwd);
+    await envService.status(key);
 }

package/dist/service/BaseService.js

@@ -4,10 +4,10 @@ export class BaseService {
     constructor(terraformAdapter) {
         this.terraformAdapter = terraformAdapter;
     }
-    getKey(key, cwd) {
+    getKey(key) {
         if (!key) {
             console.log('Key is not provided, inferring from state file');
-            key = this.terraformAdapter.getTerraformBackend(cwd).getKey();
+            key = this.terraformAdapter.getTerraformBackend().getKey();
         }
         return key;
     }

package/dist/service/EnvService.js

@@ -11,8 +11,8 @@ export class EnvService extends BaseService {
         this.cli = cli;
         this.envApi = envApi;
     }
-    async status(key, cwd) {
-        key = this.getKey(key, cwd);
+    async status(key) {
+        key = this.getKey(key);
         console.log(`Retrieve env ${key}`);
         const env = await this.envApi.get(key);
         if (env === null) {
@@ -33,7 +33,7 @@ export class EnvService extends BaseService {
             console.log(`Expires at ${formattedDate}`);
         }
         if (env.kind) {
-            const kind = this.cli.getKind(cwd);
+            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`);
             }
@@ -50,37 +50,34 @@ export class EnvService extends BaseService {
         }
         return env;
     }
-    checkKind(env, cwd) {
+    checkKind(env) {
         if (env.ephemeral)
             return;
         if (env.kind) {
-            const kind = this.cli.getKind(cwd);
+            const kind = this.cli.getKind();
             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`);
             }
         }
     }
-    async plan(tfArgs, cwd) {
-        const key = this.terraformAdapter.getTerraformBackend(cwd).getKey();
+    async plan(tfArgs) {
+        const key = this.terraformAdapter.getTerraformBackend().getKey();
         const env = await this.tryGetEnv(key);
-        let vars = undefined;
         if (env) {
-            this.checkKind(env, cwd);
+            this.checkKind(env);
             if (env.status === EnvStatus.Deleting) {
                 throw new KnownException(`Env ${env.key} status is DELETING, please wait`);
             }
-            vars = env.vars;
         }
-        const envTerraform = { key, ephemeral: false, args: tfArgs, vars };
-        await this.terraformAdapter.plan(envTerraform, cwd);
+        await this.terraformAdapter.plan(env, tfArgs);
     }
     async createEphemeral(key) {
         const createEnv = { key };
         return await this.envApi.createEphemeral(createEnv);
     }
-    async lockTerraform(env, cwd, newEnv = false) {
-        console.log('Validate terraform.tfstate file');
-        const res = await this.terraformAdapter.lock(newEnv, cwd);
+    async lockTerraform(env, newEnv = false) {
+        console.log('Lock providers');
+        const res = await this.terraformAdapter.lock(newEnv);
         if (res.lockFile) {
             env.lockFile = res.lockFile;
         }
@@ -88,68 +85,67 @@ export class EnvService extends BaseService {
             env.stateFile = res.stateFile;
         }
     }
-    async deploy(tfArgs, cwd) {
-        const key = this.terraformAdapter.getTerraformBackend(cwd).getKey();
+    async ensurePlan(env, args) {
+        if (args.length > 0 && !args[0].startsWith('-')) {
+            return args;
+        }
+        const planFile = '.terraform/envctl.plan';
+        await this.terraformAdapter.plan(env, [`-out=${planFile}`, ...args]);
+        return [planFile, ...args].filter(arg => !arg.startsWith('-var'));
+    }
+    async deploy(tfArgs) {
+        const key = this.terraformAdapter.getTerraformBackend().getKey();
         let env = await this.tryGetEnv(key);
         if (env === null) {
-            const kind = this.cli.getKind(cwd);
+            const kind = this.cli.getKind();
             console.log(`Inferred kind from directory name: ${kind}`);
             const createEnv = { key, kind };
-            await this.lockTerraform(createEnv, cwd, true);
+            await this.lockTerraform(createEnv, true);
+            tfArgs = await this.ensurePlan(env, tfArgs);
             console.log('Creating env metadata');
             env = await this.envApi.create(createEnv);
-            await this.runDeploy(env, key, tfArgs, cwd);
+            await this.runDeploy(env, tfArgs);
             return;
         }
-        this.checkKind(env, cwd);
-        switch (env.status) {
-            case EnvStatus.Init:
-            case 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);
-                await this.envApi.lockForUpdate(env);
-                break;
-            case EnvStatus.Deploying:
-            case EnvStatus.Updating:
-                const answerYes = await this.cli.promptYesNo(`Env status is ${env.status}, likely due to an error from a previous run\n
+        this.checkKind(env);
+        const status = env.status;
+        if (status === EnvStatus.Deleting) {
+            throw new KnownException(`Env ${env.key} status is DELETING, please wait`);
+        }
+        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?`);
-                if (!answerYes) {
-                    console.log('Aborting deployment');
-                    return;
-                }
-                break;
-            case EnvStatus.Deleting:
-                throw new KnownException(`Env ${env.key} status is DELETING, please wait`);
+            if (!answerYes) {
+                console.log('Aborting deployment');
+                return;
+            }
         }
-        await this.runDeploy(env, key, tfArgs, cwd);
-    }
-    async runDeploy(env, key, tfArgs, cwd) {
-        console.log('Deploying resources');
-        const { ephemeral, vars } = env;
-        const envTerraform = { key, ephemeral, args: tfArgs, vars };
-        const onDemandVars = {};
-        try {
-            await this.terraformAdapter.apply(envTerraform, onDemandVars, cwd);
-        }
-        finally {
-            if (!ephemeral) {
-                const newVars = this.terraformAdapter.getNewVars(envTerraform, onDemandVars, cwd);
-                if (Object.keys(newVars).length) {
-                    await this.envApi.setVars(env, newVars);
-                }
+        if (status === EnvStatus.Init || status === EnvStatus.Active) {
+            console.log(`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)');
             }
+            await this.envApi.lockForUpdate(env);
+            await this.runDeploy(env, tfArgs);
+            return;
         }
+        tfArgs = await this.ensurePlan(env, tfArgs);
+        await this.runDeploy(env, tfArgs);
+    }
+    async runDeploy(env, tfArgs) {
+        console.log('Deploying resources');
+        await this.terraformAdapter.apply(tfArgs);
         console.log('Activating env (to finish creation)');
         await this.envApi.activate(env);
     }
-    async delete(force, key, cwd) {
-        key = this.getKey(key, cwd);
+    async delete(force, key) {
+        key = this.getKey(key);
         await this.envApi.delete(key, force);
     }
-    async destroy(tfArgs, force, cwd) {
-        const key = this.terraformAdapter.getTerraformBackend(cwd).getKey();
+    async destroy(tfArgs, force) {
+        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`);
@@ -163,9 +159,7 @@ export class EnvService extends BaseService {
             console.log('Lock env to run destroy');
             await this.envApi.lockForUpdate(env);
         }
-        const { ephemeral, vars } = env;
-        const envTerraform = { key, ephemeral, args: tfArgs, vars };
-        await this.terraformAdapter.destroy(envTerraform, force, cwd);
+        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');
     }

package/dist/service/LocalStateService.js

@@ -3,9 +3,8 @@ import path from 'path';
 const CURRENT_VERSION = 1;
 export class LocalStateService {
     config;
-    filePath(cwd) {
-        cwd = cwd || process.cwd();
-        return path.join(cwd, '.terraform', 'envctl.json');
+    filePath() {
+        return path.join(process.cwd(), '.terraform', 'envctl.json');
     }
     createEmptyConfig(filePath) {
         fs.mkdirSync(path.dirname(filePath), { recursive: true });
@@ -13,12 +12,12 @@ export class LocalStateService {
         fs.writeFileSync(filePath, JSON.stringify(this.config, null, 2));
         return this.config;
     }
-    load(cwd) {
+    load() {
         if (this.config) {
             return this.config;
         }
         console.log('Load local state config');
-        const filePath = this.filePath(cwd);
+        const filePath = this.filePath();
         if (!fs.existsSync(filePath)) {
             console.warn('Local state file does not exist, must have been accidentally deleted, re-initializing');
             return this.createEmptyConfig(filePath);
@@ -32,13 +31,13 @@ export class LocalStateService {
         this.config = config;
         return config;
     }
-    save(config, cwd) {
+    save(config) {
         if (!this.config) {
             throw new Error('call init or load first');
         }
-        const mergedConfig = { ...this.load(cwd), ...config };
+        const mergedConfig = { ...this.load(), ...config };
         const data = JSON.stringify(mergedConfig, null, 2);
-        const filePath = this.filePath(cwd);
+        const filePath = this.filePath();
         fs.writeFileSync(filePath, data);
     }
 }

package/dist/service/LogService.js

@@ -10,8 +10,8 @@ export class LogService extends BaseService {
         this.cli = cli;
         this.envApi = envApi;
     }
-    async getLogs(key, cwd) {
-        key = this.getKey(key, cwd);
+    async getLogs(key) {
+        key = this.getKey(key);
         const url = await this.envApi.getLogs(key);
         const urlPath = new URL(url).pathname;
         const gzName = basename(urlPath);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agilecustoms/envctl",
   "description": "node.js CLI client for manage environments",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "author": "Alex Chekulaev",
   "type": "module",
   "engines": {