@agilecustoms/envctl 0.5.1 → 0.7.0

package/README.md

@@ -2,6 +2,12 @@
 - npm [@agilecustoms/envctl](https://www.npmjs.com/package/@agilecustoms/envctl)
 - npm [agilecustoms/packages](https://www.npmjs.com/settings/agilecustoms/packages) (admin view)
 
+## usage
+```shell
+envctl deploy --key tt-alexc --owner laxa1986 --size min --type dev \
+    -var-file=versions.tfvars -var="env=tt-alex" -var="log_level=debug"
+```
+
 ## setup/update
 ```shell
 npm install -g @agilecustoms/envctl # same command for update

package/dist/client/EnvApiClient.js

@@ -0,0 +1,54 @@
+import { KnownException, NotFoundException } from '../exceptions.js';
+import { HttpClient } from './HttpClient.js';
+export class EnvApiClient {
+    httpClient;
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+    }
+    async get(key) {
+        try {
+            return await this.httpClient.fetch(`/ci/env/${key}`);
+        }
+        catch (error) {
+            if (error instanceof NotFoundException) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async create(env) {
+        const res = await this.httpClient.fetch('/ci/env', {
+            method: 'POST',
+            body: JSON.stringify(env),
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        });
+        return res.token;
+    }
+    async activate(key) {
+        await this.httpClient.fetch(`/ci/env/${key}/activate`, {
+            method: 'POST'
+        });
+    }
+    async lockForUpdate(key) {
+        await this.httpClient.fetch(`/ci/env/${key}/lock-for-update`, {
+            method: 'POST'
+        });
+    }
+    async delete(key) {
+        let result;
+        try {
+            result = await this.httpClient.fetch(`/ci/env/${key}`, {
+                method: 'DELETE'
+            });
+        }
+        catch (error) {
+            if (error instanceof NotFoundException) {
+                throw new KnownException(`Environment ${key} is not found`);
+            }
+            throw error;
+        }
+        return result.statusText;
+    }
+}

package/dist/client/HttpClient.js

@@ -0,0 +1,74 @@
+import { fromEnv, fromNodeProviderChain } from '@aws-sdk/credential-providers';
+import { CredentialsProviderError } from '@smithy/property-provider';
+import aws4 from 'aws4';
+import { BusinessException, HttpException, KnownException, NotFoundException } from '../exceptions.js';
+const HOST = 'env-api.maintenance.agilecustoms.com';
+export class HttpClient {
+    creds = undefined;
+    async fetch(path, options = {}) {
+        if (!this.creds) {
+            this.creds = await this.getCredentials();
+        }
+        const requestOptions = {
+            method: options.method,
+            body: options.body,
+            headers: (options.headers ?? {}),
+            host: HOST,
+            service: 'execute-api',
+            path,
+        };
+        const signedOptions = aws4.sign(requestOptions, this.creds);
+        const signedHeaders = signedOptions.headers;
+        const url = `https://${HOST}${path}`;
+        options.headers = signedHeaders;
+        let response;
+        try {
+            response = await fetch(url, options);
+        }
+        catch (error) {
+            throw new Error('Error (network?) making the request:', { cause: error });
+        }
+        const contentType = response.headers?.get('Content-Type') || '';
+        if (response.ok) {
+            if (contentType.includes('application/json')) {
+                return await response.json();
+            }
+            else {
+                return await response.text();
+            }
+        }
+        if (response.status === 404) {
+            const message = await response.text();
+            throw new NotFoundException(message);
+        }
+        if (response.status === 422) {
+            let message = await response.text();
+            let params;
+            if (contentType.includes('application/json')) {
+                const json = await response.json();
+                message = json.message;
+                params = json.params;
+            }
+            throw new BusinessException(message, params);
+        }
+        throw new HttpException(response.status, await response.text());
+    }
+    async getCredentials() {
+        let identityProvider;
+        if (process.env.CI) {
+            identityProvider = fromEnv();
+        }
+        else {
+            identityProvider = fromNodeProviderChain();
+        }
+        try {
+            return await identityProvider();
+        }
+        catch (error) {
+            if (error instanceof CredentialsProviderError) {
+                throw new KnownException(error.message, { cause: error });
+            }
+            throw new Error('Error fetching credentials:', { cause: error });
+        }
+    }
+}

package/dist/client/ProcessRunner.js

@@ -0,0 +1,51 @@
+import { spawn } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { ProcessException } from '../exceptions.js';
+export class ProcessRunner {
+    async runScript(script, args, cwd, scanner) {
+        const __dirname = path.dirname(fileURLToPath(import.meta.url));
+        const scriptPath = path.join(__dirname, `../../scripts/${script}`);
+        return this.run(scriptPath, args, cwd, scanner);
+    }
+    async run(command, args, cwd, scanner) {
+        const spawnOptions = {};
+        if (cwd) {
+            spawnOptions.cwd = cwd;
+        }
+        const child = spawn(command, args, spawnOptions);
+        child.stdout.setEncoding('utf8');
+        child.stderr.setEncoding('utf8');
+        let buffer = '';
+        child.stdout.on('data', (data) => {
+            buffer += data;
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                if (scanner)
+                    scanner(line);
+                console.log(`> ${line}`);
+            }
+        });
+        let errorBuffer = '';
+        child.stderr.on('data', (data) => {
+            errorBuffer += data;
+        });
+        return new Promise((resolve, reject) => {
+            child.on('close', (code) => {
+                if (scanner)
+                    scanner(buffer);
+                console.log(`> ${buffer}`);
+                if (code === 0) {
+                    if (errorBuffer) {
+                        console.warn('Process completed successfully, but there were errors:\n' + errorBuffer);
+                    }
+                    resolve();
+                }
+                else {
+                    reject(new ProcessException(code, errorBuffer));
+                }
+            });
+        });
+    }
+}

package/dist/client/TerraformAdapter.js

@@ -0,0 +1,88 @@
+import { promptYesNo } from '../commands/utils.js';
+import { ExitException, KnownException, ProcessException } from '../exceptions.js';
+const MAX_ATTEMPTS = 2;
+const RETRYABLE_ERRORS = [
+    'ConcurrentModificationException',
+    'public policies are blocked by the BlockPublicPolicy block public access setting'
+];
+export class TerraformAdapter {
+    processRunner;
+    constructor(processRunner) {
+        this.processRunner = processRunner;
+    }
+    printTime() {
+        const now = new Date();
+        const utc = now.toISOString();
+        const est = now.toLocaleString('en-US', {
+            timeZone: 'America/New_York'
+        });
+        console.log(`\nTime EST: ${est},  UTC: ${utc}\n`);
+    }
+    async init(key, cwd) {
+        let emptyDir = false;
+        const scanner = (line) => {
+            if (line.includes('Terraform initialized in an empty directory!')) {
+                emptyDir = true;
+            }
+        };
+        this.printTime();
+        try {
+            await this.processRunner.runScript('terraform-init.sh', [key], cwd, scanner);
+            this.printTime();
+        }
+        catch (error) {
+            if (error instanceof ProcessException) {
+                throw new KnownException(`terraform init failed with code ${error.code}:\n${error.message}`, { cause: error });
+            }
+            throw error;
+        }
+        if (emptyDir) {
+            throw new KnownException('Can not find terraform files. Command needs to be run in a directory with terraform files');
+        }
+    }
+    async deploy(envAttrs, tfArgs, cwd, attemptNo = 1) {
+        const args = [
+            `-var=project=${envAttrs.project}`,
+            `-var=env=${envAttrs.env}`,
+            `-var=owner=${envAttrs.owner}`,
+            `-var=env_size=${envAttrs.size}`,
+            `-var=env_type=${envAttrs.type}`,
+            ...tfArgs
+        ];
+        console.log('Running:', 'terraform apply -auto-approve', ...args);
+        this.printTime();
+        try {
+            await this.processRunner.run('terraform', ['apply', '-auto-approve', ...args], cwd);
+            this.printTime();
+        }
+        catch (error) {
+            if (error instanceof ProcessException) {
+                if (attemptNo < MAX_ATTEMPTS && RETRYABLE_ERRORS.some(err => error.message.includes(err))) {
+                    console.warn(`Retrying terraform apply due to error: ${error.message}`);
+                    return this.deploy(envAttrs, tfArgs, cwd, attemptNo + 1);
+                }
+                if (attemptNo < MAX_ATTEMPTS && error.message.includes('Error acquiring the state lock')) {
+                    const match = error.message.match(/ID:\s+([a-f0-9-]{36})/i);
+                    if (match) {
+                        console.error(error.message);
+                        const answerYes = await 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? (y/n): ');
+                        if (answerYes) {
+                            console.log('Force unlocking state');
+                            const id = match[1];
+                            await this.processRunner.run('terraform', ['force-unlock', '-force', id], cwd);
+                            console.info('State unlocked, retrying terraform apply');
+                            return this.deploy(envAttrs, tfArgs, cwd, attemptNo + 1);
+                        }
+                        else {
+                            throw new ExitException();
+                        }
+                    }
+                }
+                throw new KnownException(`terraform apply failed with code ${error.code}:\n${error.message}`, { cause: error });
+            }
+            throw error;
+        }
+    }
+}

package/dist/client/index.js

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

package/dist/commands/delete.js

@@ -1,13 +1,14 @@
 import { Command } from 'commander';
 import { envCtl } from '../container.js';
-import { wrap } from '../exceptions.js';
+import { wrap } from './utils.js';
 export function deleteIt(program) {
     program
         .command('delete')
         .description('Delete a development environment')
-        .argument('<string>', 'key used to create/register the environment')
+        .requiredOption('--project <project>', 'Project name: can be project code (like tt when deploy whole project), or {code}-{microservice} if you want to deploy a single microservice')
+        .requiredOption('--env <env>', 'Environment name (can be git hash). {project}-{env} give env key used to store env state (s3 key in case of AWS)')
         .action(wrap(handler));
 }
-async function handler(key) {
-    await envCtl.delete(key);
+async function handler(options) {
+    await envCtl.delete(options.project, options.env);
 }

package/dist/commands/deploy.js

@@ -0,0 +1,22 @@
+import { Command } from 'commander';
+import { envCtl } from '../container.js';
+import { wrap } from './utils.js';
+export function deploy(program) {
+    program
+        .command('deploy')
+        .description('Create new or update existing dev environment')
+        .requiredOption('--project <project>', 'Project name: can be project code (like tt when deploy whole project), or {code}-{microservice} if you want to deploy a single microservice')
+        .requiredOption('--env <env>', 'Environment name (can be git hash). {project}-{env} give env key used to store env state (s3 key in case of AWS)')
+        .requiredOption('--owner <owner>', 'Environment owner (GH username)')
+        .requiredOption('--size <size>', 'Environment size: min, small, full')
+        .requiredOption('--type <type>', 'Environment type: dev, prod')
+        .option('--cwd <cwd>', 'Working directory (default: current directory)')
+        .allowUnknownOption(true)
+        .argument('[args...]')
+        .action(wrap(handler));
+}
+async function handler(tfArgs, options) {
+    const { project, env, owner, size, type } = options;
+    const envAttributes = { project, env, owner, size, type };
+    await envCtl.deploy(envAttributes, tfArgs, options.cwd);
+}

package/dist/commands/index.js

@@ -1,4 +1,2 @@
-export { ephemeral } from './create-ephemeral.js';
-export { register } from './register.js';
+export { deploy } from './deploy.js';
 export { deleteIt } from './delete.js';
-export { terraformInit } from './terraform-init.js';

package/dist/commands/utils.js

@@ -0,0 +1,33 @@
+import { stdin as input, stdout as output } from 'process';
+import { createInterface } from 'readline/promises';
+import { BusinessException, ExitException, KnownException } from '../exceptions.js';
+export function wrap(callable) {
+    return async (...args) => {
+        let result;
+        try {
+            result = await callable(...args);
+        }
+        catch (error) {
+            if (error instanceof KnownException || error instanceof BusinessException) {
+                console.error(error.message);
+            }
+            else if (!(error instanceof ExitException)) {
+                console.error('Unknown error:', error);
+            }
+            process.exit(1);
+        }
+        if (result !== undefined) {
+            console.log(result);
+        }
+    };
+}
+export async function prompt(question) {
+    const rl = createInterface({ input, output });
+    const answer = await rl.question(question);
+    rl.close();
+    return answer;
+}
+export async function promptYesNo(question) {
+    const answer = await prompt(question);
+    return answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes';
+}

package/dist/container.js

@@ -1,7 +1,9 @@
-import { STSClient } from '@aws-sdk/client-sts';
-import { DevEnvClient, EnvCtl, HttpClient } from './service/index.js';
-const stsClient = new STSClient();
+import { EnvApiClient, HttpClient, TerraformAdapter } from './client/index.js';
+import { ProcessRunner } from './client/ProcessRunner.js';
+import { EnvCtl } from './service/index.js';
 const httpClient = new HttpClient();
-const devEnvClient = new DevEnvClient(httpClient);
-const envCtl = new EnvCtl(stsClient, devEnvClient);
+const envApiClient = new EnvApiClient(httpClient);
+const processRunner = new ProcessRunner();
+const terraformAdapter = new TerraformAdapter(processRunner);
+const envCtl = new EnvCtl(envApiClient, terraformAdapter);
 export { envCtl };

package/dist/exceptions.js

@@ -1,9 +1,15 @@
 export class KnownException extends Error {
-    constructor(message) {
-        super(message);
+    constructor(message, options) {
+        super(message, options);
         this.name = 'KnownException';
     }
 }
+export class ExitException extends Error {
+    constructor() {
+        super();
+        this.name = 'ExitException';
+    }
+}
 export class HttpException extends Error {
     statusCode;
     responseBody;
@@ -14,31 +20,27 @@ export class HttpException extends Error {
         this.name = 'HttpException';
     }
 }
-export function wrap(callable) {
-    return async (...args) => {
-        let result;
-        try {
-            result = await callable(...args);
-        }
-        catch (error) {
-            if (error instanceof KnownException) {
-                console.error(error.message);
-            }
-            else if (error instanceof HttpException) {
-                if (error.statusCode === 422) {
-                    console.error(`Validation error: ${error.responseBody}`);
-                }
-                else {
-                    console.error(error.message);
-                }
-            }
-            else {
-                console.error('Unknown error:', error);
-            }
-            process.exit(1);
-        }
-        if (result !== undefined) {
-            console.log(result);
-        }
-    };
+export class BusinessException extends HttpException {
+    message;
+    params;
+    constructor(message, params) {
+        super(422, message);
+        this.message = message;
+        this.params = params;
+        this.name = 'BusinessException';
+    }
+}
+export class NotFoundException extends HttpException {
+    constructor(message) {
+        super(404, message);
+        this.name = 'NotFoundException';
+    }
+}
+export class ProcessException extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'ProcessException';
+    }
 }

package/dist/index.js

@@ -2,7 +2,7 @@
 import { createRequire } from 'module';
 import { Command } from 'commander';
 import updateNotifier from 'update-notifier';
-import { deleteIt, ephemeral, register, terraformInit } from './commands/index.js';
+import { deleteIt, deploy } from './commands/index.js';
 const require = createRequire(import.meta.url);
 const pkg = require('../package.json');
 updateNotifier({ pkg, updateCheckInterval: 0 }).notify();
@@ -11,8 +11,6 @@ program
     .name('envctl')
     .description('CLI to manage environments')
     .version(pkg.version);
-register(program);
-ephemeral(program);
+deploy(program);
 deleteIt(program);
-terraformInit(program);
 program.parse(process.argv);

package/dist/service/EnvCtl.js

@@ -1,46 +1,83 @@
-import { GetCallerIdentityCommand, STSClient } from '@aws-sdk/client-sts';
+import { promptYesNo } from '../commands/utils.js';
 import { KnownException } from '../exceptions.js';
-import { DevEnvClient } from './DevEnvClient.js';
 export class EnvCtl {
-    stsClient;
-    devEnvClient;
-    constructor(stsClient, devEnvClient) {
-        this.stsClient = stsClient;
-        this.devEnvClient = devEnvClient;
+    envApi;
+    terraformAdapter;
+    constructor(envApi, terraformAdapter) {
+        this.envApi = envApi;
+        this.terraformAdapter = terraformAdapter;
     }
-    async getAccount() {
-        const command = new GetCallerIdentityCommand({});
-        let response;
-        try {
-            response = await this.stsClient.send(command);
-        }
-        catch (error) {
-            if (error instanceof Error) {
-                const message = error.message;
-                if (message.startsWith('The SSO session token') || message.startsWith('Token is expired')) {
-                    throw new KnownException(error.message);
-                }
-                if (message.startsWith('ForbiddenException: No access')) {
-                    throw new KnownException(`Original error: ${message}. Could be wrong sso_account_id in ~/.aws/config for the profile`);
-                }
+    async deploy(envDto, tfArgs, cwd) {
+        const key = `${envDto.project}-${envDto.env}`;
+        console.log(`Check if env ${key} already exists`);
+        const env = await this.envApi.get(key);
+        if (env === null) {
+            console.log(`Env ${key} does not exist, creating it`);
+            console.log('First run terraform init to download providers, this doesn\'t create any resources in AWS even S3 object');
+            await this.terraformAdapter.init(key, cwd);
+            console.log('Creating env tracking record in DynamoDB');
+            const { owner, size, type } = envDto;
+            const createEnv = { key, ephemeral: false, owner, size, type };
+            await this.envApi.create(createEnv);
+            return await this.runDeploy(key, envDto, tfArgs, cwd);
+        }
+        if (env.ephemeral) {
+            throw new KnownException(`Attempted to convert ephemeral env ${key} to non-ephemeral`);
+        }
+        if (env.owner !== envDto.owner) {
+            throw new KnownException(`Can not change env owner ${env.owner} -> ${envDto.owner}`);
+        }
+        if (env.size !== envDto.size) {
+            throw new KnownException(`Can not change env size ${env.size} -> ${envDto.size}`);
+        }
+        if (env.type !== envDto.type) {
+            throw new KnownException(`Can not change env type ${env.type} -> ${envDto.type}`);
+        }
+        if (env.status === 'CREATING') {
+            const answerYes = await promptYesNo('Env status is CREATING, likely to error in previous run\nDo you want to proceed with deployment? (y/n) ');
+            if (answerYes) {
+                await this.runDeploy(key, envDto, tfArgs, cwd);
             }
-            throw new Error('Error fetching account', { cause: error });
         }
-        return response.Account;
-    }
-    async registerEnv(key, owner) {
-        const account = await this.getAccount();
-        const env = { account, key, owner };
-        return await this.devEnvClient.registerEnv(env);
+        else if (env.status === 'UPDATING') {
+            const answerYes = await promptYesNo('Env status is UPDATING, likely to error in previous run\nDo you want to proceed with deployment? (y/n) ');
+            if (answerYes) {
+                await this.runDeploy(key, envDto, tfArgs, cwd);
+            }
+        }
+        else if (env.status === 'ACTIVE') {
+            console.log('Env status is ACTIVE\nWill lock for update and run terraform apply (to update resources)');
+            await this.envApi.lockForUpdate(key);
+            await this.runDeploy(key, envDto, tfArgs, cwd);
+        }
     }
-    async createEphemeralEnv(key) {
-        const account = await this.getAccount();
-        const env = { account, key };
-        return await this.devEnvClient.createEphemeralEnv(env);
+    async runDeploy(key, envAttrs, tfArgs, cwd) {
+        console.log('Deploying resources');
+        await this.terraformAdapter.deploy(envAttrs, tfArgs, cwd);
+        console.log('Activating env (to finish creation)');
+        await this.envApi.activate(key);
+        console.log('Lock env to run db evolution');
+        await this.envApi.lockForUpdate(key);
+        console.log('Unlock env after db evolution');
+        await this.envApi.activate(key);
     }
-    async delete(key) {
-        const account = await this.getAccount();
-        const envId = `${account}-${key}`;
-        return this.devEnvClient.delete(envId);
+    async delete(project, envName) {
+        const key = `${project}-${envName}`;
+        console.log(`Retrieve env`);
+        const env = await this.envApi.get(key);
+        if (env === null) {
+            throw new KnownException(`Environment ${key} does not exist`);
+        }
+        if (env.status === 'CREATING') {
+            const answerYes = await promptYesNo('Environment is still being created.\nDo you want to delete it? (y/n) ');
+            if (!answerYes) {
+                throw new KnownException('Aborting env deletion');
+            }
+            console.log('Activate (unlock) env (so it can be deleted)');
+            await this.envApi.activate(key);
+        }
+        console.log('Deleting env');
+        const statusMessage = await this.envApi.delete(key);
+        console.log(statusMessage);
     }
 }

package/dist/service/index.js

@@ -1,3 +1 @@
-export { DevEnvClient } from './DevEnvClient.js';
 export { EnvCtl } from './EnvCtl.js';
-export { HttpClient } from './HttpClient.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agilecustoms/envctl",
   "description": "node.js CLI client for manage environments",
-  "version": "0.5.1",
+  "version": "0.7.0",
   "author": "Alex Chekulaev",
   "type": "module",
   "bin": {
@@ -25,11 +25,9 @@
     "test": "vitest run --coverage",
     "build": "tsc",
     "run": "node dist/index.js",
-    "run-version": "tsc --sourceMap true; npm run run -- --version",
-    "run-register": "tsc --sourceMap true; npm run run -- register --project tt --env alexc --owner laxa1986",
-    "run-ephemeral": "tsc --sourceMap true; npm run run -- ephemeral -p tt -e tempenv",
-    "run-delete": "tsc --sourceMap true; npm run run -- delete tt-alexc",
-    "run-terraform-init": "tsc --sourceMap true; npm run run -- terraform-init test"
+    "run-version": "tsc --sourceMap true && npm run run -- --version",
+    "run-deploy": "tsc --sourceMap true && AWS_PROFILE=ac-tt-dev-deployer npm run run -- deploy --project tt-core --env alexc --owner laxa1986 --size min --type dev --cwd ../tt-core",
+    "run-delete": "tsc --sourceMap true && AWS_PROFILE=ac-tt-dev-deployer npm run run -- delete --project tt-core --env alexc"
   },
   "dependencies": {
     "@aws-sdk/client-sts": "^3.716.0",

package/scripts/terraform-init.sh

@@ -3,23 +3,16 @@ set -euo pipefail
 
 KEY="${1:?}"
 
-echo "KEY: ${KEY}"
+# TF state is stored in S3 in format: {company}-{acc-alias}-tf-state/{key}
+# (for non ephemeral environments the {key} typically has form of {project-code}-{env-name} like tt-dev)
+# Retrieve AWS account information
+acc_id=$(aws sts get-caller-identity --query "Account" --output text)
+acc_alias=$(aws organizations list-tags-for-resource --resource-id "$acc_id" --query "Tags[?Key=='Alias'].Value" --output text)
+state_prefix="agilecustoms-$acc_alias" # like "agilecustoms-tt-dev"
 
-#echo "time: $(TZ=America/New_York date +"%T") ETD ($(date -u +"%T") UTC)"
-#echo
-#
-## TF stored in S3 in format: {company}-{acc-alias}-tf-state/{env} where {acc-alias} has form of {project-code}-{env-kind} like tt-dev
-## Retrieve AWS account information
-#acc_id=$(aws sts get-caller-identity --query "Account" --output text)
-#acc_alias=$(aws organizations list-tags-for-resource --resource-id "$acc_id" --query "Tags[?Key=='Alias'].Value" --output text)
-#state_prefix="agilecustoms-$acc_alias" # like "agilecustoms-tt-dev"
-#
-## -upgrade - get latest version of providers (mainly hashicorp/aws)
-## -reconfigure - discard local state, use (or create) remote
-## added to allow deploy multiple envs from local machine (on CI no local state survive between runs)
-#terraform init -upgrade -reconfigure \
-# -backend-config="bucket=$state_prefix-tf-state" \
-# -backend-config="key=$KEY"
-#
-#echo
-#echo "time: $(TZ=America/New_York date +"%T") ETD ($(date -u +"%T") UTC)"
+# -upgrade - get latest version of providers (mainly hashicorp/aws)
+# -reconfigure - discard local state, use (or create) remote
+#                added to allow deploy multiple envs from local machine (on CI no local state survive between runs)
+terraform init -upgrade -reconfigure \
+ -backend-config="bucket=$state_prefix-tf-state" \
+ -backend-config="key=$KEY"

package/dist/commands/create-ephemeral.js

@@ -1,14 +0,0 @@
-import { Command } from 'commander';
-import { envCtl } from '../container.js';
-import { wrap } from '../exceptions.js';
-export function ephemeral(program) {
-    program
-        .command('ephemeral')
-        .description('Create new ephemeral environment')
-        .requiredOption('-k, --key <key>', 'Key used to store env state (s3 key in case of AWS). Can be git hash, feature-a or {project-code}-{env-name}')
-        .action(wrap(handler));
-}
-async function handler(options) {
-    const { key } = options;
-    return await envCtl.createEphemeralEnv(key);
-}

package/dist/commands/register.js

@@ -1,15 +0,0 @@
-import { Command } from 'commander';
-import { envCtl } from '../container.js';
-import { wrap } from '../exceptions.js';
-export function register(program) {
-    program
-        .command('register')
-        .description('Create new or update existing dev environment')
-        .requiredOption('-k, --key <key>', 'Key used to store env state (s3 key in case of AWS). Can be git hash, feature-a or {project-code}-{env-name}')
-        .requiredOption('-o, --owner <owner>', 'Environment owner (GH username)')
-        .action(wrap(handler));
-}
-async function handler(options) {
-    const { key, owner } = options;
-    return await envCtl.registerEnv(key, owner);
-}

package/dist/commands/terraform-init.js

@@ -1,31 +0,0 @@
-import { execFile } from 'child_process';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { Command } from 'commander';
-import { wrap } from '../exceptions.js';
-export function terraformInit(program) {
-    program
-        .command('terraform-init')
-        .description('Wrapper for terraform init, to initialize a development environment')
-        .argument('<string>', 'key used to create/register the environment')
-        .action(wrap(handler));
-}
-async function handler(key) {
-    const __dirname = path.dirname(fileURLToPath(import.meta.url));
-    const scriptPath = path.join(__dirname, '../../scripts/terraform-init.sh');
-    const child = execFile(scriptPath, [key], (error, stdout, stderr) => {
-        if (error) {
-            console.error(`Script failed: ${error.message}`);
-            return;
-        }
-        if (stdout)
-            console.log(stdout);
-        if (stderr)
-            console.error(stderr);
-    });
-    child.on('exit', (code) => {
-        if (code !== 0) {
-            console.log(`Shell script exited with code ${code}`);
-        }
-    });
-}

package/dist/model/PersonalEnvironment.js

@@ -1 +0,0 @@
-export {};

package/dist/service/DevEnvClient.js

@@ -1,38 +0,0 @@
-import { HttpException, KnownException } from '../exceptions.js';
-import { HttpClient } from './HttpClient.js';
-export class DevEnvClient {
-    httpClient;
-    constructor(httpClient) {
-        this.httpClient = httpClient;
-    }
-    async registerEnv(env) {
-        return await this.send('PUT', '/ci/env', env);
-    }
-    async createEphemeralEnv(env) {
-        return await this.send('POST', '/ci/env', env);
-    }
-    async delete(envId) {
-        try {
-            await this.httpClient.fetch(`/ci/env/${envId}`, {
-                method: 'DELETE'
-            });
-        }
-        catch (error) {
-            if (error instanceof HttpException) {
-                if (error.statusCode === 404) {
-                    throw new KnownException(`Environment ${envId} is not found`);
-                }
-                throw error;
-            }
-        }
-    }
-    async send(method, path, env) {
-        return this.httpClient.fetch(path, {
-            method,
-            body: JSON.stringify(env),
-            headers: {
-                'Content-Type': 'application/json'
-            }
-        });
-    }
-}

package/dist/service/HttpClient.js

@@ -1,48 +0,0 @@
-import { fromEnv, fromSSO } from '@aws-sdk/credential-providers';
-import aws4 from 'aws4';
-import { HttpException } from '../exceptions.js';
-const HOST = 'env-api.maintenance.agilecustoms.com';
-export class HttpClient {
-    async fetch(path, options) {
-        const creds = await this.getCredentials();
-        const requestOptions = {
-            method: options.method,
-            body: options.body,
-            headers: options.headers,
-            host: HOST,
-            service: 'execute-api',
-            path,
-        };
-        const signedOptions = aws4.sign(requestOptions, creds);
-        const signedHeaders = signedOptions.headers;
-        const url = `https://${HOST}${path}`;
-        options.headers = signedHeaders;
-        let response;
-        try {
-            response = await fetch(url, options);
-        }
-        catch (error) {
-            throw new Error('Error (network?) making the request:', { cause: error });
-        }
-        const text = await response.text();
-        if (!response.ok) {
-            throw new HttpException(response.status, text);
-        }
-        return text;
-    }
-    async getCredentials() {
-        let identityProvider;
-        if (process.env.CI) {
-            identityProvider = fromEnv();
-        }
-        else {
-            identityProvider = fromSSO();
-        }
-        try {
-            return await identityProvider();
-        }
-        catch (error) {
-            throw new Error('Error fetching credentials:', { cause: error });
-        }
-    }
-}