@firestartr/cli 1.55.0-snapshot-0 → 1.55.0-snapshot-2

package/build/index.js

@@ -355878,7 +355878,7 @@ function createCodeOwnersData(claim, additionalRules) {
         message = concatLine(message, `\n${paddedAsterisk}${resolveCodeownersRef(claim.owner, claim.providers.github.org)}`);
     }
     if (claim.platformOwner) {
-        message = concatLine(message, `\n${paddedAsterisk}${resolveCodeownersRef(claim.platformOwner, claim.providers.github.org)}`);
+        message = concatLine(message, `\n${'/.github/'.padEnd(25)}${resolveCodeownersRef(claim.platformOwner, claim.providers.github.org)}`);
     }
     if (additionalRules) {
         for (const rule of additionalRules) {
@@ -357903,7 +357903,7 @@ const external_node_child_process_namespaceObject = __WEBPACK_EXTERNAL_createReq
                         },
                         owner: {
                             type: 'string',
-                            pattern: '^(user|group):[a-zA-Z0-9_-]+$',
+                            pattern: '^(user|group):\\S+$',
                         },
                     },
                     required: ['description', 'owner'],
@@ -359701,6 +359701,9 @@ var ajv_default = /*#__PURE__*/__nccwpck_require__.n(dist_ajv);
                 $arg: {
                     type: 'string',
                 },
+                $template: {
+                    type: 'string',
+                },
                 $default: {
                     type: ['string', 'array', 'boolean'],
                 },
@@ -360681,8 +360684,24 @@ function buildContext(entity, args, firestartrConfig, featureArgs) {
     });
     context.firestartrConfig = firestartrConfig;
     context.traceability = featureArgs['traceability'] || {};
+    buildTemplateArgs(args, context);
     return context;
 }
+/**
+ * Mutates the provided context object by adding properties for each argument
+ * that has a `$template`, using the current context to render the template content.
+ *
+ * @param args - Argument definitions, where each entry may contain a `$template` key.
+ * @param context - The context object to be mutated with rendered template values.
+ * @returns void
+ */
+function buildTemplateArgs(args, context) {
+    Object.entries(args).forEach(([key, arg]) => {
+        if ('$template' in arg) {
+            context[key] = renderContent(arg['$template'], context);
+        }
+    });
+}
 function expandFiles(featurePath, configData, context) {
     let files = [];
     for (const tpl of configData.filesTemplates) {
@@ -360692,7 +360711,17 @@ function expandFiles(featurePath, configData, context) {
     context.config.files = context.config.files.concat(files).flat(Infinity);
 }
 function expandFilesTemplate(featurePath, tplPath, context) {
-    const template = external_fs_default().readFileSync(external_path_default().join(featurePath, tplPath)).toString();
+    const templatePath = external_path_default().join(featurePath, tplPath);
+    features_renderer_src_logger.debug(`Expanding files section with template located at ${templatePath}`);
+    let template;
+    try {
+        template = external_fs_default().readFileSync(templatePath).toString();
+    }
+    catch (err) {
+        const message = err && err.message ? err.message : String(err);
+        features_renderer_src_logger.error(`Failed to read template file at "${templatePath}": ${message}`);
+        throw new Error(`Failed to read template file at "${templatePath}": ${message}`);
+    }
     const renderedTemplate = renderContent(template, context);
     const data = catalog_common.io.fromYaml(renderedTemplate) || { files: [] };
     if (!data.files)
@@ -367709,12 +367738,28 @@ async function addDestroyCommitStatus(cr, state, description = '', context = '')
 async function addPlanStatusCheck(prUrl, summary, status = 'in_progress', isFailure = false) {
     try {
         operator_src_logger.debug(`The ctl is checking the length of the plan summary, which is '${summary.length}'.`);
-        if (summary.length > MAX_CHARS_OUPUT_PLAN) {
+        // Determine if we should wrap in fences
+        const shouldWrap = status === 'completed' && !summary.includes('```');
+        const FENCE_OVERHEAD = 17; // "```terraform\n" + "\n```"
+        let processedSummary = summary;
+        if (shouldWrap) {
+            // Truncate accounting for fence overhead
+            const maxBodyLength = MAX_CHARS_OUPUT_PLAN - FENCE_OVERHEAD;
+            if (summary.length > maxBodyLength) {
+                const mustDrop = summary.length - maxBodyLength;
+                processedSummary = summary.substring(mustDrop);
+                operator_src_logger.debug(`The ctl found the plan summary too lengthy (length: '${summary.length}'). The summary must drop because '${mustDrop}'.`);
+            }
+            // Wrap in fences
+            processedSummary = `\`\`\`terraform\n${processedSummary}\n\`\`\``;
+        }
+        else if (summary.length > MAX_CHARS_OUPUT_PLAN) {
+            // Truncate without wrapping
             const mustDrop = summary.length - MAX_CHARS_OUPUT_PLAN;
-            summary = summary.substring(mustDrop);
+            processedSummary = summary.substring(mustDrop);
             operator_src_logger.debug(`The ctl found the plan summary too lengthy (length: '${summary.length}'). The summary must drop because '${mustDrop}'.`);
         }
-        await ctl_addStatusCheck({ summary, title: 'Terraform Plan Results' }, isFailure, 'terraform_plan', prUrl, status);
+        await ctl_addStatusCheck({ summary: processedSummary, title: 'Terraform Plan Results' }, isFailure, 'terraform_plan', prUrl, status);
     }
     catch (e) {
         operator_src_logger.error(`The ctl encountered an error while adding plan status for PR '${prUrl}' with status '${status}'. Is Failure: '${isFailure}'. Error: '${e}'.`);
@@ -367854,29 +367899,91 @@ async function observe(plural, namespace, onAdd, onChange, onDelete, _onRename)
     }
 }
 
+;// CONCATENATED MODULE: ../operator/src/high_priority_status.ts
+
+const SORTED_PRIORITIES = [
+    'PROVISIONING',
+    'ERROR',
+    'OUT_OF_SYNC',
+    'PLANNING',
+    'DELETING',
+    'SYNCHRONIZED',
+    'PROVISIONED',
+    'DELETED',
+];
+function setHighPriorityStatus(item) {
+    const highPriorityCondition = conditionsSorter(item.status?.conditions || []);
+    let highPriorityState = null;
+    if (highPriorityCondition) {
+        highPriorityState = {
+            type: highPriorityCondition.type,
+            reason: highPriorityCondition.reason,
+        };
+    }
+    else {
+        highPriorityState = {
+            type: 'UNKNOWN',
+            reason: 'AwaitingReconciliation',
+        };
+    }
+    item.status.highPriorityState = highPriorityState.type;
+    item.status.highPriorityReason = highPriorityState.reason;
+    operator_src_logger.silly(`${item.kind}/${item.metadata.name} - Set HighPriorityStatus to ${item.status.highPriorityState} - ${item.status.highPriorityReason}`);
+}
+function conditionsSorter(conditions) {
+    if (conditions.length === 0)
+        return null;
+    const getPriority = (type) => {
+        const index = SORTED_PRIORITIES.indexOf(type);
+        return index === -1 ? Number.MAX_SAFE_INTEGER : index;
+    };
+    return conditions
+        .filter((condition) => {
+        return condition.status === 'True';
+    })
+        .sort((a, b) => {
+        const priorityA = getPriority(a.type);
+        const priorityB = getPriority(b.type);
+        return priorityA - priorityB;
+    })[0];
+}
+
 ;// CONCATENATED MODULE: ../operator/src/status.ts
 
 
-async function needsProvisioningOnCreate(cr) {
+
+async function upsertInitialStatus(pluralKind, namespace, item) {
+    item = await getItemByItemPath(`${namespace}/${pluralKind}/${item.metadata.name}`);
+    if (!('status' in item))
+        item.status = {};
+    if (!('conditions' in item.status))
+        item.status.conditions = [];
+    await writePrioritizedStatus(pluralKind, namespace, item);
+}
+async function needsProvisioningOnCreateOrUpdate(cr) {
     const fCrLog = (cr) => `The item ${cr.kind}: ${cr.metadata.name}`;
     // NO STATUS
     if (!('status' in cr) || !('conditions' in cr.status)) {
         operator_src_logger.debug(`The custom resource '${cr.kind}/${cr.metadata.name}' is missing a status and any conditions.`);
-        return true;
+        return { needs: true, reason: 'CREATED' };
     }
     // ERROR
     const errCond = getConditionByType(cr.status.conditions, 'ERROR');
     if (errCond && errCond.status === 'True') {
         operator_src_logger.debug(`Skipping the provisioning process for custom resource '${cr.kind}/${cr.metadata.name}' due to a status error.`);
-        return false;
+        return { needs: false };
     }
     // PROVISIONED
     const provCond = getConditionByType(cr.status.conditions, 'PROVISIONED');
-    if (provCond &&
-        provCond.status === 'True' &&
-        provCond.observedGeneration >= cr.metadata.generation) {
-        operator_src_logger.debug(`The custom resource '${cr.kind}/${cr.metadata.name}' is already provisioned; skipping the process.`);
-        return false;
+    if (provCond && provCond.status === 'True') {
+        if (provCond.observedGeneration >= cr.metadata.generation) {
+            operator_src_logger.debug(`The custom resource '${cr.kind}/${cr.metadata.name}' is already provisioned; skipping the process.`);
+            return { needs: false };
+        }
+        else {
+            operator_src_logger.debug(`The custom resource '${cr.kind}/${cr.metadata.name}' is already provisioned but it has spec changes not observed; handling.`);
+            return { needs: true, reason: 'UPDATED' };
+        }
     }
     // DELETED
     const delCond = getConditionByType(cr.status.conditions, 'DELETED');
@@ -367884,16 +367991,16 @@ async function needsProvisioningOnCreate(cr) {
         delCond.status === 'True' &&
         delCond.observedGeneration >= cr.metadata.generation) {
         operator_src_logger.debug(`The custom resource '${cr.kind}/${cr.metadata.name}' has already been deleted; no action is required.`);
-        return false;
+        return { needs: false };
     }
     // PROVISIONING
     const provisioningCondition = getConditionByType(cr.status.conditions, 'PROVISIONING');
     if (provisioningCondition && provisioningCondition.status === 'True') {
         operator_src_logger.debug(`The custom resource '${cr.kind}/${cr.metadata.name}' is currently in a provisioning or reprovisioning state.`);
-        return true;
+        return { needs: true, reason: 'UPDATED' };
     }
     operator_src_logger.debug(`Skipping the provisioning process for custom resource '${cr.kind}/${cr.metadata.name}' because its current state is not handled.`);
-    return false;
+    return { needs: false };
 }
 async function updateSyncTransition(itemPath, reason, lastSyncTime, nextSyncTime, message, status) {
     operator_src_logger.info(`The item at '${itemPath}' transitioned to a new SYNCHRONIZED condition of '${status}'. The reason for the change is '${reason}' with the message: '${message}'.`);
@@ -367915,7 +368022,11 @@ async function updateSyncTransition(itemPath, reason, lastSyncTime, nextSyncTime
     };
     k8sItem.status.conditions = updateConditionByType(k8sItem.status.conditions, 'SYNCHRONIZED', conditionObject);
     const itemParameters = itemPath.split('/');
-    await writeStatus(itemParameters[1], itemParameters[0], k8sItem);
+    await writePrioritizedStatus(itemParameters[1], itemParameters[0], k8sItem);
+}
+async function writePrioritizedStatus(kind, namespace, item) {
+    setHighPriorityStatus(item);
+    await writeStatus(kind, namespace, item);
 }
 async function updateTransition(itemPath, reason, type, statusValue, message = '', updateStatusOnly = false) {
     operator_src_logger.info(`The item at '${itemPath}' transitioned to a new status of '${statusValue}' (type: '${type}'). The reason for the change is '${reason}' with the message: '${message}'. This was a status-only update: '${updateStatusOnly}'.`);
@@ -367933,7 +368044,7 @@ async function updateTransition(itemPath, reason, type, statusValue, message = '
     }
     k8sItem.status.conditions = updateConditionByType(k8sItem.status.conditions, type, conditionObject);
     const itemParameters = itemPath.split('/');
-    await writeStatus(itemParameters[1], itemParameters[0], k8sItem);
+    await writePrioritizedStatus(itemParameters[1], itemParameters[0], k8sItem);
 }
 function getRelevantCondition(conditionList, type) {
     const condition = getConditionByType(conditionList, type);
@@ -368628,6 +368739,7 @@ async function observeKind(pluralKind, namespace, queue, compute) {
     async (item) => {
         operator_src_logger.info(`The informer has detected a new item, '${item.metadata.name}', for '${pluralKind}' in namespace '${namespace}'.`);
         await handleUpsertFinalizer(pluralKind, namespace, item);
+        await upsertInitialStatus(pluralKind, namespace, item);
         const workItem = await inform(pluralKind, item, 'onAdd', getLastWorkItem(pluralKind, lastWorkItems, item));
         syncCtl.addItem(informer_itemPath(pluralKind, item));
         if (workItem) {
@@ -368784,6 +368896,7 @@ function setLastWorkItem(kind, workItemsMap, item, workItem) {
  */
 async function inform(pluralKind, item, op, lastWorkItem = null) {
     let workItem = lastWorkItem;
+    let needed;
     if (getKindFromPlural(pluralKind) !== item.kind)
         return null;
     switch (op) {
@@ -368800,8 +368913,9 @@ async function inform(pluralKind, item, op, lastWorkItem = null) {
             };
             return workItem;
         case 'onRename':
-            if (await needsProvisioningOnCreate(item)) {
-                operator_src_logger.debug(`The informer is triggering a new provisioning process for the renamed item '${item.kind}/${item.metadata.name}'.`);
+            needed = await needsProvisioningOnCreateOrUpdate(item);
+            if (needed.needs) {
+                operator_src_logger.debug(`The informer is triggering a new provisioning process for the renamed item '${item.kind}/${item.metadata.name}'. Reason: ${needed.reason}.`);
                 workItem = {
                     operation: OperationType.RENAMED,
                     item,
@@ -368825,9 +368939,12 @@ async function inform(pluralKind, item, op, lastWorkItem = null) {
             };
             return workItem;
         case 'onAdd':
-            if (await needsProvisioningOnCreate(item)) {
+            needed = await needsProvisioningOnCreateOrUpdate(item);
+            if (needed.needs) {
                 workItem = {
-                    operation: OperationType.CREATED,
+                    operation: needed.reason === 'CREATED'
+                        ? OperationType.CREATED
+                        : OperationType.UPDATED,
                     item,
                     workStatus: WorkStatus.PENDING,
                     onDelete: function () { },
@@ -369408,6 +369525,58 @@ async function deadLetterHandler(workItem) {
     }
 }
 
+;// CONCATENATED MODULE: ../operator/src/signals.ts
+
+const DEFAULT_TERMINATION_GRACE_PERIOD = 2 * 60; // two minutes
+/**
+ * Initializes process signal handlers used by the operator.
+ *
+ * Currently this sets up handling for `SIGTERM`, using the callback
+ * associated with the `"SIGTERM"` key from the provided {@link CallbacksMap}
+ * to start the shutdown sequence. The returned {@link CallbacksMap} contains
+ * handler-specific callbacks (such as `"FINISH_OK"`) that callers can invoke
+ * to indicate that it is safe for the process to exit.
+ *
+ * @param callbacks A map of signal names to shutdown callbacks. The `"SIGTERM"`
+ *   entry (if present) is invoked when a `SIGTERM` signal is received to
+ *   perform any necessary cleanup before process termination.
+ * @returns A {@link CallbacksMap} with control callbacks that allow the caller
+ *   to signal when shutdown has completed and the process may safely exit.
+ */
+function initSignalsHandler(callbacks) {
+    operator_src_logger.info('Starting signals handler');
+    const handlerCallbacks = new Map();
+    initSigtermHandler(callbacks.get('SIGTERM'), handlerCallbacks);
+    return handlerCallbacks;
+}
+function initSigtermHandler(callback, handlerCallbacks) {
+    const raw_timeout_to_exit = Number(process.env['FIRESTARTR_TERMINATION_GRACE_PERIOD'] ||
+        DEFAULT_TERMINATION_GRACE_PERIOD);
+    const timeout_to_exit = raw_timeout_to_exit - Math.round(Math.min(5, raw_timeout_to_exit * 0.1));
+    // The switch to control if it is safe to exit
+    let finish = false;
+    handlerCallbacks.set('FINISH_OK', () => {
+        finish = true;
+    });
+    process.on('SIGTERM', async () => {
+        operator_src_logger.info('The controller received a SIGTERM signal');
+        // we signal to the callback the sigterm
+        callback();
+        const timeoutCb = setTimeout(() => {
+            operator_src_logger.error('The controller could not shutdown properly. Timeout');
+            process.exit(1);
+        }, timeout_to_exit * 1000);
+        // we wait
+        while (!finish) {
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+        }
+        // all is clear!
+        clearTimeout(timeoutCb);
+        operator_src_logger.info('The controller has properly shutdown. Exiting');
+        process.exit(0);
+    });
+}
+
 ;// CONCATENATED MODULE: ../operator/src/processItem.ts
 
 
@@ -369415,6 +369584,7 @@ async function deadLetterHandler(workItem) {
 
 
 
+
 const queue = [];
 const WEIGHTS = {
     RENAMED: 15,
@@ -369524,7 +369694,15 @@ async function processItem_loop() {
         .filter((w) => !w.isBlocked)
         .find((w) => w.workStatus === WorkStatus.PENDING);
     loopWorkItemDebug(queue);
+    let podIsTerminating = false;
+    const handlerCallbacks = initSignalsHandler(new Map([['SIGTERM', () => (podIsTerminating = true)]]));
     while (1) {
+        if (podIsTerminating) {
+            operator_src_logger.info('The processor is going to shutdown (pod is terminating)');
+            // we notify the handler that is ok to shutdown
+            handlerCallbacks.get('FINISH_OK')();
+            break;
+        }
         const w = nextWorkItem();
         if (w) {
             const logMessage = `${new Date().toISOString()} : Processing OPERATION: ${w.operation} ITEM: ${w.item.kind}/${w.item.metadata.name}`;
@@ -369984,9 +370162,10 @@ var actions_repository_oidc_subject_claim_customization_template = __nccwpck_req
 function provisionOIDCSubjectClaim(scope, repo, fsGithubRepository) {
     const tfStateKey = `_${fsGithubRepository.getTfStateKey()}-oidc-subject-claim-template`;
     const claimKeys = fsGithubRepository.spec.actions.oidc.includeClaimKeys;
+    const useDefault = fsGithubRepository.spec.actions.oidc.useDefault;
     const config = {
         repository: repo.name,
-        useDefault: claimKeys.length < 1,
+        useDefault,
     };
     if (claimKeys.length > 0) {
         config['includeClaimKeys'] = claimKeys;
@@ -371590,19 +371769,19 @@ if (process.env.RUN_PROVISIONER) {
 
 
 const LAST_STATE_PR_ANNOTATION = 'firestartr.dev/last-state-pr';
-async function tryPublishApply(item, planOutput, kind) {
+async function tryPublishApply(item, planOutput, kind, isSuccess = true) {
     try {
         if (!(LAST_STATE_PR_ANNOTATION in item.metadata.annotations)) {
             operator_src_logger.debug(`The user feedback for the '${kind}/${item.metadata.name}' apply operation could not be published because the last state was not found.`);
             return;
         }
-        await publishApply(item, planOutput, kind);
+        await publishApply(item, planOutput, kind, isSuccess);
     }
     catch (e) {
         operator_src_logger.error(`The user feedback for the '${kind}/${item.metadata.name}' apply operation failed to publish due to an error: '${e}'.`);
     }
 }
-async function tryPublishDestroy(item, destroyOutput) {
+async function tryPublishDestroy(item, destroyOutput, isSuccess = true) {
     let lastPr = null;
     try {
         const { repo, org } = extractPrInfo(item);
@@ -371621,11 +371800,13 @@ async function tryPublishDestroy(item, destroyOutput) {
             return;
         }
         const dividedOutput = github_0.pulls.divideCommentIntoChunks(destroyOutput, 250);
+        const statusEmoji = isSuccess ? '✅' : '❌';
+        const statusText = isSuccess ? 'Succeeded' : 'Failed';
         const commentBodies = dividedOutput.map((commentContent, index) => {
             const isMultiPart = dividedOutput.length > 1;
             const partIndicator = isMultiPart ? ` (Part ${index + 1})` : '';
             return `<h1>
-<img  width="25"  src="https://raw.githubusercontent.com/firestartr-pro/docs/refs/heads/main/logos/square-nobg.png"> Destroy Finished
+<img  width="25"  src="https://raw.githubusercontent.com/firestartr-pro/docs/refs/heads/main/logos/square-nobg.png"> Destroy ${statusText} ${statusEmoji}
 </h1>
 <p><b>TFWorkspace: </b>${item.metadata.name}</p>
 
@@ -371653,14 +371834,16 @@ ${commentContent}
         operator_src_logger.error(`An error occurred while publishing user feedback for item '${item.kind}/${item.metadata.name}': '${e}'.`);
     }
 }
-async function publishApply(item, applyOutput, kind) {
+async function publishApply(item, applyOutput, kind, isSuccess = true) {
     const { prNumber, repo, org } = extractPrInfo(item);
     const dividedOutput = github_0.pulls.divideCommentIntoChunks(applyOutput, 250);
+    const statusEmoji = isSuccess ? '✅' : '❌';
+    const statusText = isSuccess ? 'Succeeded' : 'Failed';
     const commentBodies = dividedOutput.map((commentContent, index) => {
         const isMultiPart = dividedOutput.length > 1;
         const partIndicator = isMultiPart ? ` (Part ${index + 1})` : '';
         return `<h1>
-<img  width="25"  src="https://raw.githubusercontent.com/firestartr-pro/docs/refs/heads/main/logos/square-nobg.png"> Apply Finished
+<img  width="25"  src="https://raw.githubusercontent.com/firestartr-pro/docs/refs/heads/main/logos/square-nobg.png"> Apply ${statusText} ${statusEmoji}
 </h1>
 <p><b>${kind}: </b>${item.metadata.name}</p>
 
@@ -371735,14 +371918,16 @@ ${message}
 `;
     await github_0.pulls.commentInPR(comment, prNumber, repo, org, 'logs');
 }
-async function publishPlan(item, planOutput, prNumber, repo, org) {
+async function publishPlan(item, planOutput, prNumber, repo, org, isSuccess = true) {
     try {
         const dividedOutput = github_0.pulls.divideCommentIntoChunks(planOutput, 250);
+        const statusEmoji = isSuccess ? '✅' : '❌';
+        const statusText = isSuccess ? 'Succeeded' : 'Failed';
         const commentBodies = dividedOutput.map((commentContent, index) => {
             const isMultiPart = dividedOutput.length > 1;
             const partIndicator = isMultiPart ? ` (Part ${index + 1})` : '';
             return `<h1>
-<img  width="25"  src="https://raw.githubusercontent.com/firestartr-pro/docs/refs/heads/main/logos/square-nobg.png"> Plan Finished
+<img  width="25"  src="https://raw.githubusercontent.com/firestartr-pro/docs/refs/heads/main/logos/square-nobg.png"> Plan ${statusText} ${statusEmoji}
 </h1>
 <p><b>TFWorkspace: </b>${item.metadata.name}</p>
 
@@ -371980,7 +372165,6 @@ async function* cdktf_markedToDeletion(item, op, handler) {
                 : {}),
         });
         const output = destroyOutput.output;
-        await tryPublishDestroy(item, output);
         yield {
             item,
             reason: op,
@@ -371993,15 +372177,24 @@ async function* cdktf_markedToDeletion(item, op, handler) {
         if (item.metadata.annotations['firestartr.dev/last-state-pr'] || false) {
             await addDestroyCommitStatus(item, 'success', 'Destroy operation completed', `Terraform Destroy ${item.metadata.name}`);
         }
+        await tryPublishDestroy(item, output, true);
         void handler.success();
     }
     catch (e) {
         error = true;
+        let errorMsg;
+        if (typeof e === 'object' && 'output' in e) {
+            errorMsg = e.output;
+        }
+        else {
+            errorMsg = e;
+        }
         // if there is a current checkRun working
         // we close it with an error
         if (checkRunCtl)
-            checkRunCtl.fnOnError(e);
-        await handler.writeTerraformOutputInTfResult(item, e);
+            checkRunCtl.fnOnError(errorMsg);
+        await tryPublishDestroy(item, errorMsg, false);
+        await handler.writeTerraformOutputInTfResult(item, errorMsg);
         void handler.error();
     }
     finally {
@@ -372109,7 +372302,6 @@ async function* doApply(item, op, handler) {
                 }
                 : {}),
         });
-        await tryPublishApply(item, applyOutput?.data?.output, item.kind);
         const terraformOutputJson = await provisioner.runTerraform(item, ['output', '-json'], null);
         if (!terraformOutputJson) {
             throw new Error(`Terraform output is empty for ${item.kind}/${item.metadata.name}`);
@@ -372138,7 +372330,8 @@ async function* doApply(item, op, handler) {
             message: 'doApply',
         };
         await handler.writeTerraformOutputInTfResult(item, output);
-        handler.success();
+        await tryPublishApply(item, applyOutput?.data?.output, item.kind, true);
+        void handler.success();
     }
     catch (e) {
         error = true;
@@ -373725,7 +373918,6 @@ async function* process_operation_markedToDeletion(item, op, handler) {
         const deps = await handler.resolveReferences();
         const context = buildProvisionerContext(item, deps);
         const destroyOutput = await runTerraformProvisioner(context, 'destroy');
-        await tryPublishDestroy(item, destroyOutput);
         yield {
             item,
             reason: op,
@@ -373745,11 +373937,20 @@ async function* process_operation_markedToDeletion(item, op, handler) {
         if (item.metadata.annotations['firestartr.dev/last-state-pr'] || false) {
             await addDestroyCommitStatus(item, 'success', 'Destroy operation completed', `Terraform Destroy ${item.metadata.name}`);
         }
+        await tryPublishDestroy(item, destroyOutput, true);
         void handler.success();
     }
     catch (e) {
         error = true;
-        await handler.writeTerraformOutputInTfResult(item, e);
+        let errorMsg;
+        if (typeof e === 'object' && 'output' in e) {
+            errorMsg = e.output;
+        }
+        else {
+            errorMsg = e;
+        }
+        await tryPublishDestroy(item, errorMsg, false);
+        await handler.writeTerraformOutputInTfResult(item, errorMsg);
         if (item.metadata.annotations['firestartr.dev/last-state-pr'] || false) {
             await addDestroyCommitStatus(item, 'failure', 'Destroy operation failed', `Terraform Destroy ${item.metadata.name}`);
         }
@@ -373834,7 +374035,6 @@ async function* process_operation_doApply(item, op, handler) {
         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);
-        await tryPublishApply(item, applyOutput, 'TFWorkspace');
         const terraformOutputJson = await runTerraformProvisioner(context, 'output');
         if (!terraformOutputJson) {
             throw new Error(`Terraform output is empty for ${item.kind}/${item.metadata.name}`);
@@ -373865,17 +374065,25 @@ async function* process_operation_doApply(item, op, handler) {
             message: 'doApply',
         };
         await handler.writeTerraformOutputInTfResult(item, output);
+        await tryPublishApply(item, applyOutput, 'TFWorkspace', true);
         handler.success();
     }
     catch (e) {
         error = true;
-        checkRunCtl.fnOnError(e);
+        let errorMsg;
+        if (typeof e === 'object' && 'output' in e) {
+            errorMsg = e.output;
+        }
+        else {
+            errorMsg = e;
+        }
+        checkRunCtl.fnOnError(errorMsg);
         console.error(e);
-        await tryPublishApply(item, e, 'TFWorkspace');
+        await tryPublishApply(item, errorMsg, 'TFWorkspace', false);
         operator_src_logger.error(`The Terraform processor encountered an error during operation '${op}' for item '${item.kind}/${item.metadata.name}': '${e}'.`);
         handler.error();
-        if (e) {
-            await handler.writeTerraformOutputInTfResult(item, e);
+        if (errorMsg) {
+            await handler.writeTerraformOutputInTfResult(item, errorMsg);
         }
     }
     finally {
@@ -374122,7 +374330,6 @@ function clearLocalTfProjects() {
     external_fs_.rmSync(TF_PROJECTS_PATH, { recursive: true, force: true });
 }
 function getErrorOutputMessage(cr, key, ref) {
-    const result = '';
     if (cr.spec.source === 'Remote') {
         return `
 
@@ -374341,8 +374548,6 @@ async function* doPlanPlainTextFormat(item, op, handler, action) {
             await addPlanStatusCheck(item.metadata.annotations['firestartr.dev/last-state-pr'], 'Terraform plan in progress...');
         }
         const tfPlanOutput = await runTerraformProvisioner(context, action);
-        const { prNumber, repo, org } = extractPrInfo(item, 'firestartr.dev/pull-request-plan');
-        await publishPlan(item, tfPlanOutput, prNumber, repo, org);
         yield {
             item,
             reason: op,
@@ -374367,11 +374572,13 @@ async function* doPlanPlainTextFormat(item, op, handler, action) {
         if (item.metadata.annotations['firestartr.dev/last-state-pr'] || false) {
             await addPlanStatusCheck(item.metadata.annotations['firestartr.dev/last-state-pr'], tfPlanOutput, 'completed');
         }
+        const { prNumber, repo, org } = extractPrInfo(item, 'firestartr.dev/pull-request-plan');
+        await publishPlan(item, tfPlanOutput, prNumber, repo, org, true);
     }
     catch (e) {
         error = true;
         const { prNumber, repo, org } = extractPrInfo(item, 'firestartr.dev/pull-request-plan');
-        await publishPlan(item, JSON.stringify(e), prNumber, repo, org);
+        await publishPlan(item, JSON.stringify(e), prNumber, repo, org, false);
         operator_src_logger.error('TFWORKSPACE_PROCESSOR_PLAN_OBSERVING_ERROR', {
             metadata: { item, error: e },
         });
@@ -375977,6 +376184,10 @@ const crs_analyzerSubcommand = {
     },
 };
 
+;// CONCATENATED MODULE: ./package.json
+const package_namespaceObject = JSON.parse('{"i8":"1.55.0-snapshot-2"}');
+;// CONCATENATED MODULE: ../../package.json
+const package_namespaceObject_1 = {"i8":"1.54.0"};
 ;// CONCATENATED MODULE: ./src/subcommands/index.ts
 
 
@@ -375985,6 +376196,8 @@ const crs_analyzerSubcommand = {
 
 
 
+
+
 const SUBCOMMANDS = {
     import: importSubcommand,
     importer: importSubcommand,
@@ -376022,6 +376235,9 @@ function showSubcommandsHelp() {
     console.log('AVAILABLE COMMANDS');
     console.table(commandsList);
 }
+function showCliVersion() {
+    console.log(`CLI Version: ${package_namespaceObject.i8}. Firestartr Version: ${package_namespaceObject_1.i8}`);
+}
 
 ;// CONCATENATED MODULE: ./src/command_line.ts
 
@@ -376042,6 +376258,9 @@ class CommandLine {
             case 'help':
                 showSubcommandsHelp();
                 break;
+            case 'version':
+                showCliVersion();
+                break;
             default: {
                 // Get the subcommand data
                 const subcommandData = validateAndGetSubcommand(subcommand);

package/build/packages/cli/src/subcommands/index.d.ts

@@ -1,3 +1,4 @@
 import { Subcommand } from '../types';
 export declare function validateAndGetSubcommand(name: string): Subcommand;
 export declare function showSubcommandsHelp(): void;
+export declare function showCliVersion(): void;

package/build/packages/features_renderer/src/schema.d.ts

@@ -66,6 +66,9 @@ declare const _default: {
                 $arg: {
                     type: string;
                 };
+                $template: {
+                    type: string;
+                };
                 $default: {
                     type: string[];
                 };

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

@@ -0,0 +1 @@
+export declare function setHighPriorityStatus(item: any): void;

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

@@ -0,0 +1,17 @@
+export type CallbacksMap = Map<string, () => void>;
+/**
+ * Initializes process signal handlers used by the operator.
+ *
+ * Currently this sets up handling for `SIGTERM`, using the callback
+ * associated with the `"SIGTERM"` key from the provided {@link CallbacksMap}
+ * to start the shutdown sequence. The returned {@link CallbacksMap} contains
+ * handler-specific callbacks (such as `"FINISH_OK"`) that callers can invoke
+ * to indicate that it is safe for the process to exit.
+ *
+ * @param callbacks A map of signal names to shutdown callbacks. The `"SIGTERM"`
+ *   entry (if present) is invoked when a `SIGTERM` signal is received to
+ *   perform any necessary cleanup before process termination.
+ * @returns A {@link CallbacksMap} with control callbacks that allow the caller
+ *   to signal when shutdown has completed and the process may safely exit.
+ */
+export declare function initSignalsHandler(callbacks: CallbacksMap): CallbacksMap;

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

@@ -1,4 +1,10 @@
-export declare function needsProvisioningOnCreate(cr: any): Promise<boolean>;
+export type NeedsCreationOrUpdate = {
+    needs: boolean;
+    reason?: string;
+};
+export declare function upsertInitialStatus(pluralKind: string, namespace: string, item: any): Promise<void>;
+export declare function needsProvisioningOnCreateOrUpdate(cr: any): Promise<NeedsCreationOrUpdate>;
 export declare function updateSyncTransition(itemPath: string, reason: string, lastSyncTime: string, nextSyncTime: string, message: string, status: string): Promise<void>;
+export declare function writePrioritizedStatus(kind: string, namespace: string, item: any): Promise<void>;
 export declare function updateTransition(itemPath: string, reason: string, type: string, statusValue: string, message?: string, updateStatusOnly?: boolean): Promise<void>;
 export declare function getConditionByType(conditionList: Array<any>, type: string): any;

package/build/packages/operator/src/user-feedback-ops/user-feedback-ops.d.ts

@@ -1,6 +1,6 @@
-export declare function tryPublishApply(item: any, planOutput: string, kind: string): Promise<void>;
-export declare function tryPublishDestroy(item: any, destroyOutput: string): Promise<void>;
-export declare function publishApply(item: any, applyOutput: string, kind: string): Promise<void>;
+export declare function tryPublishApply(item: any, planOutput: string, kind: string, isSuccess?: boolean): Promise<void>;
+export declare function tryPublishDestroy(item: any, destroyOutput: string, isSuccess?: boolean): Promise<void>;
+export declare function publishApply(item: any, applyOutput: string, kind: string, isSuccess?: boolean): Promise<void>;
 export declare function tryCreateErrorSummary(title: string, errorMsg: string): string;
 export declare function extractPrInfo(item: any, annotation?: 'firestartr.dev/last-state-pr' | 'firestartr.dev/pull-request-plan'): {
     prNumber: number;
@@ -9,4 +9,4 @@ export declare function extractPrInfo(item: any, annotation?: 'firestartr.dev/la
 };
 export declare function tryPublishError(item: any, reason: string, message: string): Promise<void>;
 export declare function publishError(item: any, reason: string, message: string): Promise<void>;
-export declare function publishPlan(item: any, planOutput: string, prNumber: number, repo: string, org: string): Promise<void>;
+export declare function publishPlan(item: any, planOutput: string, prNumber: number, repo: string, org: string, isSuccess?: boolean): Promise<void>;

package/package.json

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