@firestartr/cli 1.59.3-snapshot-02 → 1.59.3-snapshot-03

package/build/index.js

@@ -366782,7 +366782,7 @@ class MemberGithubDecanter extends GithubDecanter {
         this.claim = {
             kind: this.claimKind,
             version: this.VERSION(),
-            name: this.data.memberDetails.login,
+            name: this.data.memberDetails.login.toLowerCase(),
             profile: {
                 displayName: this.data.memberDetails.login,
                 email: this.data.memberDetails.email
@@ -367689,6 +367689,25 @@ function definitions_getPluralFromKind(kind) {
     const plural = Object.keys(kindPluralMap).find((key) => kindPluralMap[key] === kind);
     return plural;
 }
+const DAY_SECONDS = 24 * 60 * 60;
+const TIMEOUTS = {
+    // expressed in seconds
+    RENAMED: DAY_SECONDS,
+    UPDATED: DAY_SECONDS,
+    CREATED: DAY_SECONDS,
+    RETRY: 120 * 60,
+    MARKED_TO_DELETION: DAY_SECONDS,
+    SYNC: DAY_SECONDS,
+    NOTHING: 10,
+};
+function getTimeoutForOperation(operation) {
+    if (operation in TIMEOUTS) {
+        return TIMEOUTS[operation];
+    }
+    else {
+        throw new Error(`getTimeoutForOperation: Unknown operation: ${operation}`);
+    }
+}
 
 ;// CONCATENATED MODULE: ../operator/src/pr-annotation.ts
 
@@ -369200,6 +369219,19 @@ function enqueue(pluralKind, workItem, queue, compute, syncCtl, retryCtl) {
         itemPath: () => informer_itemPath(pluralKind, workItem.item),
         error: () => retryCtl.errorReconciling(informer_itemPath(pluralKind, workItem.item)),
         success: () => retryCtl.successReconciling(informer_itemPath(pluralKind, workItem.item)),
+        recommendedTimeout: () => {
+            const customTimeoutAnnotation = catalog_common.generic.getFirestartrAnnotation('test-custom-timeout');
+            let customTimeout = null;
+            if ('annotations' in workItem.item.metadata &&
+                customTimeoutAnnotation in workItem.item.metadata.annotations &&
+                !isNaN(parseInt(workItem.item.metadata.annotations[customTimeoutAnnotation]))) {
+                customTimeout = parseInt(workItem.item.metadata.annotations[customTimeoutAnnotation]);
+            }
+            else {
+                customTimeout = getTimeoutForOperation(workItem.operation);
+            }
+            return customTimeout;
+        },
         needsBlocking: (item, operation) => {
             if (kindsWithDependants.indexOf(item.kind) === -1) {
                 return false;
@@ -370052,16 +370084,6 @@ function getQueueMetrics() {
 //   "FirestartrGithubRepositoryFeature": 1,
 //   "FirestartrTerraformWorkspacePlan": 1,
 // }
-const TIMEOUTS = {
-    // expressed in seconds
-    RENAMED: 30 * 60,
-    UPDATED: 60 * 60,
-    CREATED: 60 * 60,
-    RETRY: 60 * 60,
-    MARKED_TO_DELETION: 60 * 60,
-    SYNC: 60 * 60,
-    NOTHING: 10,
-};
 let INIT = false;
 /**
  * Pushes a WorkItem to the queue
@@ -370099,27 +370121,12 @@ async function processItem_loop() {
         if (w) {
             const logMessage = `${new Date().toISOString()} : Processing OPERATION: ${w.operation} ITEM: ${w.item.kind}/${w.item.metadata.name}`;
             catalog_common.io.writeLogFile('process_item', logMessage);
-            const timeout = createTimeout(w);
             operator_src_logger.info(`The processor is currently handling a '${w.operation}' operation for item '${w.item.kind}/${w.item.metadata.name}' in namespace '${w.item.metadata.namespace}'. The current work status is '${w.workStatus}'.`);
             await runWorkItem(w);
-            clearTimeout(timeout);
         }
         await processItem_wait();
     }
 }
-/**
- * Creates a timeout for a workItem
- *
- *
- **/
-function createTimeout(w) {
-    return setTimeout(() => {
-        //throw new Error('Timeout on workitem ' + w);
-        console.error('Timeout on workitem %O', w);
-        operator_src_logger.error(`The processor timed out while handling a '${w.operation}' operation for item '${w.item.kind}/${w.item.metadata.name}' in namespace '${w.item.metadata.namespace}'. The current work status is '${w.workStatus}'.`);
-        process.exit(1);
-    }, TIMEOUTS[w.operation] * 1000);
-}
 /**
  * Sorts the queue based on the operation type
  * @param {WorkItem[]} queue - store of WorkItems
@@ -373108,11 +373115,82 @@ class TFPlanItemVersion extends TFPlanItem {
 
 /* harmony default export */ const terraform_provisioner_src_logger = (catalog_common.logger);
 
+;// CONCATENATED MODULE: ../terraform_provisioner/src/process_handler.ts
+
+const GRACE_PERIOD = 60 * 2; // 2 min
+const HARD_RESET_PERIOD = 10; // 10 sec
+function processHandler(processToHandle, ctl, onTimedOut) {
+    let gracefulResetId;
+    let hardResetId;
+    let callerNotified = false;
+    let timedOut = false;
+    const safeKill = (signal) => {
+        try {
+            const sent = processToHandle.kill(signal);
+            if (!sent) {
+                throw new Error(`Failed to send signal ${signal} to the process`);
+            }
+        }
+        catch (error) {
+            terraform_provisioner_src_logger.error(`FATAL: timeout signal ${signal} could not be delivered to the process: ${error}`);
+            if (!callerNotified) {
+                ctl.processKilled(false);
+                callerNotified = true;
+            }
+        }
+    };
+    const terminateId = setTimeout(() => {
+        // we take control of the process
+        onTimedOut();
+        timedOut = true;
+        // send sigInt
+        terraform_provisioner_src_logger.error(`Terraform process has not exited after initial timeout of ${ctl.hardTimeout} seconds, sending SIGINT...`);
+        safeKill('SIGINT');
+        // grace period
+        gracefulResetId = setTimeout(() => {
+            terraform_provisioner_src_logger.error(`Terraform process has not exited after SIGINT grace period of ${GRACE_PERIOD} seconds (total elapsed ~${ctl.hardTimeout + GRACE_PERIOD} seconds), sending SIGTERM...`);
+            safeKill('SIGTERM');
+            // hard reset period
+            hardResetId = setTimeout(() => {
+                terraform_provisioner_src_logger.error(`Terraform process has not exited after SIGTERM hard reset period of ${HARD_RESET_PERIOD} seconds (total elapsed ~${ctl.hardTimeout + GRACE_PERIOD + HARD_RESET_PERIOD} seconds), sending SIGKILL...`);
+                safeKill('SIGKILL');
+                setTimeout(() => {
+                    // we send if the process was killed or not to the caller
+                    if (!callerNotified) {
+                        ctl.processKilled(processToHandle.killed);
+                        callerNotified = true;
+                    }
+                }, 10 * 1000);
+            }, HARD_RESET_PERIOD * 1000);
+        }, GRACE_PERIOD * 1000);
+    }, ctl.hardTimeout * 1000);
+    processToHandle.on('exit', () => {
+        // the process has exited
+        // let's clear all the timeouts
+        if (terminateId) {
+            clearTimeout(terminateId);
+        }
+        if (gracefulResetId) {
+            clearTimeout(gracefulResetId);
+        }
+        if (hardResetId) {
+            clearTimeout(hardResetId);
+        }
+        // we inform the caller
+        // if the process exited and the timeout control has kicked-off
+        if (!callerNotified && timedOut) {
+            ctl.processKilled(true);
+            callerNotified = true;
+        }
+    });
+}
+
 ;// CONCATENATED MODULE: ../terraform_provisioner/src/utils.ts
 
 
 
 
+
 async function utils_validate(path, secrets) {
     return await tfExec(path, ['validate'], secrets);
 }
@@ -373122,28 +373200,28 @@ async function init(path, secrets, stream) {
 async function initFromModule(path, source, secrets, stream) {
     return tfExec(path, ['init', `-from-module=${source}`], secrets, [], stream);
 }
-async function plan(path, secrets, format, args = ['plan'], stream) {
+async function plan(path, secrets, format, args = ['plan'], stream, ctl) {
     terraform_provisioner_src_logger.info(`Running terraform plan with ${format} in path ${path}`);
-    const plan = await tfExec(path, args.concat(format === 'json' ? ['-json'] : []), secrets, ['-input=false'], stream);
+    const plan = await tfExec(path, args.concat(format === 'json' ? ['-json'] : []), secrets, ['-input=false'], stream, ctl);
     if (format === 'json') {
         const tfPlan = planGet(plan);
         return tfPlan;
     }
     return plan;
 }
-async function apply(path, secrets, stream) {
+async function apply(path, secrets, stream, ctl) {
     terraform_provisioner_src_logger.debug(`Running terraform apply in path ${path}`);
-    return await tfExec(path, ['apply', '-auto-approve'], secrets, ['-input=false'], stream);
+    return await tfExec(path, ['apply', '-auto-approve'], secrets, ['-input=false'], stream, ctl);
 }
-async function destroy(path, secrets, stream) {
+async function destroy(path, secrets, stream, ctl) {
     terraform_provisioner_src_logger.debug(`Running terraform destroy in path ${path}`);
-    return await tfExec(path, ['destroy', '-auto-approve'], secrets, ['-input=false'], stream);
+    return await tfExec(path, ['destroy', '-auto-approve'], secrets, ['-input=false'], stream, ctl);
 }
 async function output(path, secrets) {
     terraform_provisioner_src_logger.debug(`Running terraform output in path ${path}`);
     return await tfExec(path, ['output', '-json'], secrets, []);
 }
-async function tfExec(path, args, secrets, extraArgs = ['-input=false'], stream) {
+async function tfExec(path, args, secrets, extraArgs = ['-input=false'], stream, ctl) {
     return new Promise((ok, ko) => {
         const tfProcess = (0,external_child_process_.spawn)('tofu', args.concat(extraArgs), {
             cwd: path,
@@ -373153,6 +373231,7 @@ async function tfExec(path, args, secrets, extraArgs = ['-input=false'], stream)
         let flagStdoutEnd = false;
         let flagStderrEnd = false;
         let outputErrors = '';
+        let processTimeout = false;
         tfProcess.stdout.on('data', (log) => {
             const line = catalog_common.io.stripAnsi(log.toString());
             output += line;
@@ -373173,12 +373252,21 @@ async function tfExec(path, args, secrets, extraArgs = ['-input=false'], stream)
         });
         tfProcess.on('exit', async (code) => {
             let retryCount = 0;
-            while ((!flagStdoutEnd && !flagStderrEnd) || retryCount < 10) {
+            while (!flagStdoutEnd && !flagStderrEnd && retryCount < 10) {
                 retryCount++;
                 await catalog_common.generic.sleep(500);
             }
+            // this process has been killed/terminated
+            // by timeout (not in our control)
+            if (processTimeout) {
+                terraform_provisioner_src_logger.error(`Terraform output ${path}: ${[output, outputErrors].join('')}`);
+                ko(catalog_common.generic.buildCommandExecutionError([output, outputErrors, '\n<PROCESS TIMEOUT>'].join(''), catalog_common.generic.normalizeExitCode(code), args.concat(extraArgs), {
+                    errorName: 'TerraformCommandError',
+                    label: 'Terraform command',
+                }));
+                return;
+            }
             if (code !== 0) {
-                terraform_provisioner_src_logger.error(`Terraform output ${path}: ${output + outputErrors}`);
                 terraform_provisioner_src_logger.error(`Terraform output ${path}: ${[output, outputErrors].join('')}`);
                 ko(catalog_common.generic.buildCommandExecutionError([output, outputErrors].join(''), catalog_common.generic.normalizeExitCode(code), args.concat(extraArgs), {
                     errorName: 'TerraformCommandError',
@@ -373190,6 +373278,13 @@ async function tfExec(path, args, secrets, extraArgs = ['-input=false'], stream)
                 ok(output);
             }
         });
+        if (ctl) {
+            void processHandler(tfProcess, ctl, () => {
+                // callback to be called by the process handler
+                // we set on our flag to avoid sending our own messages
+                processTimeout = true;
+            });
+        }
     });
 }
 async function configureGit(ghToken) {
@@ -373678,6 +373773,15 @@ class project_tf_TFProjectManager {
         }
         this.secrets = ctx.secrets;
     }
+    set ctl(ctl) {
+        this._ctl = ctl;
+    }
+    get ctl() {
+        return this._ctl;
+    }
+    getOutput() {
+        return this.tfOutput;
+    }
     setStreamCallbacks(fnData, fnEnd, reopen = true) {
         if (reopen || !this.stream)
             this.stream = new external_stream_.PassThrough();
@@ -373686,9 +373790,6 @@ class project_tf_TFProjectManager {
         });
         this.stream.on('end', fnEnd);
     }
-    getOutput() {
-        return this.tfOutput;
-    }
     async build() {
         await this.mainTfWriter.render();
         this.mainTfWriter.writeToTerraformProject(external_path_.join(this.projectPath, 'firestartr-main.tf'));
@@ -373715,7 +373816,7 @@ class project_tf_TFProjectManager {
         await this.__init();
         if (format === 'json')
             this.tfOutput = null;
-        this.tfOutput = await plan(this.projectPath, this.secrets, format, ['plan'], this.stream);
+        this.tfOutput = await plan(this.projectPath, this.secrets, format, ['plan'], this.stream, this.ctl);
         if (this.stream)
             this.stream.end();
     }
@@ -373723,17 +373824,17 @@ class project_tf_TFProjectManager {
         await this.__init();
         if (format === 'json')
             this.tfOutput = null;
-        this.tfOutput = await plan(this.projectPath, this.secrets, format, ['plan', '-destroy'], this.stream);
+        this.tfOutput = await plan(this.projectPath, this.secrets, format, ['plan', '-destroy'], this.stream, this.ctl);
     }
     async apply() {
         await this.__init();
-        this.tfOutput += await apply(this.projectPath, this.secrets, this.stream);
+        this.tfOutput += await apply(this.projectPath, this.secrets, this.stream, this.ctl);
         if (this.stream)
             this.stream.end();
     }
     async destroy() {
         await this.__init();
-        this.tfOutput += await destroy(this.projectPath, this.secrets, this.stream);
+        this.tfOutput += await destroy(this.projectPath, this.secrets, this.stream, this.ctl);
         if (this.stream)
             this.stream.end();
     }
@@ -373845,6 +373946,12 @@ class TFProjectManagerRemote {
         }
         this.tfVarsJsonWriter = new WriterTfVarsJson(ctx.values, ctx.references);
     }
+    set ctl(ctl) {
+        this._ctl = ctl;
+    }
+    get ctl() {
+        return this._ctl;
+    }
     getOutput() {
         return this.tfOutput;
     }
@@ -373893,23 +374000,23 @@ insteadOf = https://github.com`);
     async plan(format) {
         await this.__init();
         if (format === 'json') {
-            this.tfOutput = await plan(this.projectPath, this.secrets, format, ['plan'], this.stream);
+            this.tfOutput = await plan(this.projectPath, this.secrets, format, ['plan'], this.stream, this.ctl);
         }
         else {
-            this.tfOutput += await plan(this.projectPath, this.secrets, format, ['plan'], this.stream);
+            this.tfOutput += await plan(this.projectPath, this.secrets, format, ['plan'], this.stream, this.ctl);
         }
         if (this.stream)
             this.stream.end();
     }
     async apply() {
         await this.__init();
-        this.tfOutput += await apply(this.projectPath, this.secrets, this.stream);
+        this.tfOutput += await apply(this.projectPath, this.secrets, this.stream, this.ctl);
         if (this.stream)
             this.stream.end();
     }
     async destroy() {
         await this.__init();
-        this.tfOutput += await destroy(this.projectPath, this.secrets, this.stream);
+        this.tfOutput += await destroy(this.projectPath, this.secrets, this.stream, this.ctl);
         if (this.stream)
             this.stream.end();
     }
@@ -373958,7 +374065,7 @@ async function run() {
     await execCommand(command, tfProject);
 }
 // Programatic API
-async function runTerraformProvisioner(context, command = 'init', streaming) {
+async function runTerraformProvisioner(context, command = 'init', streaming, ctl) {
     terraform_provisioner_src_logger.info(`Running command ${command} on a ${context.type} project`);
     validateContext(context);
     let tfProject = {};
@@ -373971,6 +374078,9 @@ async function runTerraformProvisioner(context, command = 'init', streaming) {
     if (streaming) {
         tfProject.setStreamCallbacks(streaming.fnData, streaming.fnEnd);
     }
+    if (ctl) {
+        tfProject.ctl = ctl;
+    }
     const output = await execCommand(command, tfProject);
     return output;
 }
@@ -374215,7 +374325,17 @@ async function* doPlanJSONFormat(item, op, handler, setResult = function (_r) {
         if (item.metadata.annotations['firestartr.dev/last-state-pr'] || false) {
             await addPlanStatusCheck(item.metadata.annotations['firestartr.dev/last-state-pr'], 'Terraform plan in progress...');
         }
-        const tfPlan = await runTerraformProvisioner(context, planType);
+        const tfPlan = await runTerraformProvisioner(context, planType, null, {
+            hardTimeout: handler.recommendedTimeout(),
+            processKilled: (killed) => {
+                if (killed) {
+                    operator_src_logger.error(`The Terraform process for item '${item.kind}/${item.metadata.name}' was killed due to a timeout.`);
+                }
+                else {
+                    operator_src_logger.error(`PANIC!!: The Terraform process for item '${item.kind}/${item.metadata.name}' could not be killed`);
+                }
+            },
+        });
         if (tfPlan.summary.hasChanges()) {
             yield {
                 item,
@@ -374502,7 +374622,17 @@ async function* process_operation_markedToDeletion(item, op, handler) {
         }
         const deps = await handler.resolveReferences();
         const context = buildProvisionerContext(item, deps);
-        const destroyOutput = await runTerraformProvisioner(context, 'destroy');
+        const destroyOutput = await runTerraformProvisioner(context, 'destroy', null, {
+            hardTimeout: handler.recommendedTimeout(),
+            processKilled: (killed) => {
+                if (killed) {
+                    operator_src_logger.error(`The Terraform process for item '${item.kind}/${item.metadata.name}' was killed due to a timeout.`);
+                }
+                else {
+                    operator_src_logger.error(`PANIC!!: The Terraform process for item '${item.kind}/${item.metadata.name}' could not be killed`);
+                }
+            },
+        });
         yield {
             item,
             reason: op,
@@ -374613,7 +374743,17 @@ async function* process_operation_doApply(item, op, handler) {
         const deps = await handler.resolveReferences();
         operator_src_logger.info(`The Terraform processor is applying and assessing dependencies for item '${item.kind}/${item.metadata.name}' with dependencies: '${deps}'.`);
         const context = buildProvisionerContext(item, deps);
-        const applyOutput = await runTerraformProvisioner(context, 'apply', checkRunCtl);
+        const applyOutput = await runTerraformProvisioner(context, 'apply', checkRunCtl, {
+            hardTimeout: handler.recommendedTimeout(),
+            processKilled: (killed) => {
+                if (killed) {
+                    operator_src_logger.error(`The Terraform process for item '${item.kind}/${item.metadata.name}' was killed due to a timeout.`);
+                }
+                else {
+                    operator_src_logger.error(`PANIC!!: The Terraform process for item '${item.kind}/${item.metadata.name}' could not be killed`);
+                }
+            },
+        });
         const terraformOutputJson = await runTerraformProvisioner(context, 'output');
         if (!terraformOutputJson) {
             throw new Error(`Terraform output is empty for ${item.kind}/${item.metadata.name}`);
@@ -376752,9 +376892,9 @@ const crs_analyzerSubcommand = {
 };
 
 ;// CONCATENATED MODULE: ./package.json
-const package_namespaceObject = JSON.parse('{"i8":"1.59.3-snapshot-02"}');
+const package_namespaceObject = JSON.parse('{"i8":"1.59.3-snapshot-03"}');
 ;// CONCATENATED MODULE: ../../package.json
-const package_namespaceObject_1 = {"i8":"1.58.0"};
+const package_namespaceObject_1 = {"i8":"1.59.3"};
 ;// CONCATENATED MODULE: ./src/subcommands/index.ts
 
 

package/build/packages/operator/src/definitions.d.ts

@@ -1,2 +1,3 @@
 export declare function getKindFromPlural(plural: string): any;
 export declare function getPluralFromKind(kind: string): string;
+export declare function getTimeoutForOperation(operation: string): any;

package/build/packages/operator/src/informer.d.ts

@@ -50,6 +50,7 @@ export type WorkItemHandler = {
     isBlocked?: boolean;
     needsBlocking?: (item: any, operation: OperationType) => boolean;
     fUnblock?: Function;
+    recommendedTimeout: () => number;
 };
 /**
  * Observe whenever a new item is added, modified or deleted in a given kind

package/build/packages/terraform_provisioner/index.d.ts

@@ -1,4 +1,5 @@
 export { TFProjectManager } from './src';
+import type { ProcessHandler } from './src/process_handler';
 export declare function validateContext(context: any): void;
 export declare function run(): Promise<void>;
-export declare function runTerraformProvisioner(context: any, command?: string, streaming?: any): Promise<any>;
+export declare function runTerraformProvisioner(context: any, command?: string, streaming?: any, ctl?: ProcessHandler): Promise<any>;

package/build/packages/terraform_provisioner/src/process_handler.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+import { ChildProcess } from 'child_process';
+export type ProcessHandler = {
+    processKilled(killed: boolean): void;
+    hardTimeout: number;
+};
+export declare function processHandler(processToHandle: ChildProcess, ctl: ProcessHandler, onTimedOut: Function): void;

package/build/packages/terraform_provisioner/src/project_tf.d.ts

@@ -4,6 +4,7 @@ import { WriterTfVarsJson } from './writer_tfvars_json';
 import { WriterProviderJson } from './writer_provider_tf_json';
 import { WriterAdditionalFiles } from './writer_additional_files';
 import { PassThrough } from 'stream';
+import type { ProcessHandler } from './process_handler';
 export declare class TFProjectManager {
     mainTfWriter: WriterMainTf;
     providerJsonWriter: WriterProviderJson;
@@ -13,9 +14,12 @@ export declare class TFProjectManager {
     projectPath: string;
     tfOutput: any;
     stream: PassThrough;
+    _ctl?: ProcessHandler;
     constructor(ctx: any);
-    setStreamCallbacks(fnData: Function, fnEnd: (...args: any[]) => void, reopen?: boolean): void;
+    set ctl(ctl: ProcessHandler);
+    get ctl(): ProcessHandler;
     getOutput(): any;
+    setStreamCallbacks(fnData: Function, fnEnd: (...args: any[]) => void, reopen?: boolean): void;
     build(): Promise<void>;
     __init(): Promise<void>;
     __initFromModule(): Promise<void>;

package/build/packages/terraform_provisioner/src/project_tf_remote.d.ts

@@ -4,6 +4,7 @@ import { WriterTfVarsJson } from './writer_tfvars_json';
 import { WriterProviderJson } from './writer_provider_tf_json';
 import { WriterAdditionalFiles } from './writer_additional_files';
 import { PassThrough } from 'stream';
+import type { ProcessHandler } from './process_handler';
 export declare class TFProjectManagerRemote {
     writerTerraform: WriterTerraform;
     providerJsonWriter: WriterProviderJson;
@@ -14,7 +15,10 @@ export declare class TFProjectManagerRemote {
     projectPath: string;
     tfOutput: any;
     stream: PassThrough;
+    _ctl?: ProcessHandler;
     constructor(ctx: any);
+    set ctl(ctl: ProcessHandler);
+    get ctl(): ProcessHandler | undefined;
     getOutput(): any;
     setStreamCallbacks(fnData: Function, fnEnd: (...args: any[]) => void, reopen?: boolean): void;
     build(): Promise<void>;

package/build/packages/terraform_provisioner/src/utils.d.ts

@@ -1,11 +1,12 @@
 /// <reference types="node" />
 import { PassThrough } from 'stream';
+import type { ProcessHandler } from './process_handler';
 export declare function validate(path: string, secrets: any[]): Promise<unknown>;
 export declare function init(path: string, secrets: any[], stream?: PassThrough): Promise<unknown>;
 export declare function initFromModule(path: string, source: string, secrets: any[], stream?: PassThrough): Promise<unknown>;
-export declare function plan(path: string, secrets: any[], format: 'human' | 'json', args?: string[], stream?: PassThrough): Promise<any>;
-export declare function apply(path: string, secrets: any[], stream?: PassThrough): Promise<unknown>;
-export declare function destroy(path: string, secrets: any[], stream?: PassThrough): Promise<unknown>;
+export declare function plan(path: string, secrets: any[], format: 'human' | 'json', args?: string[], stream?: PassThrough, ctl?: ProcessHandler): Promise<any>;
+export declare function apply(path: string, secrets: any[], stream?: PassThrough, ctl?: ProcessHandler): Promise<unknown>;
+export declare function destroy(path: string, secrets: any[], stream?: PassThrough, ctl?: ProcessHandler): Promise<unknown>;
 export declare function output(path: string, secrets: any[]): Promise<unknown>;
-export declare function tfExec(path: string, args: Array<string>, secrets: any[], extraArgs?: string[], stream?: PassThrough): Promise<unknown>;
+export declare function tfExec(path: string, args: Array<string>, secrets: any[], extraArgs?: string[], stream?: PassThrough, ctl?: ProcessHandler): Promise<unknown>;
 export declare function configureGit(ghToken: string): Promise<unknown>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@firestartr/cli",
-  "version": "1.59.3-snapshot-02",
+  "version": "1.59.3-snapshot-03",
   "private": false,
   "description": "Commandline tool",
   "main": "build/main.js",