@firestartr/cli 1.54.0 → 1.55.0-snapshot-1

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):.+$',
                         },
                     },
                     required: ['description', 'owner'],
@@ -359664,6 +359664,13 @@ var ajv_default = /*#__PURE__*/__nccwpck_require__.n(dist_ajv);
                         },
                     },
                 },
+                filesTemplates: {
+                    type: 'array',
+                    description: 'a list of references to a different file where files key is filled by an expanded template',
+                    items: {
+                        type: 'string',
+                    },
+                },
             },
             required: ['args', 'feature_name', 'files', 'patches'],
             title: 'root',
@@ -359683,7 +359690,7 @@ var ajv_default = /*#__PURE__*/__nccwpck_require__.n(dist_ajv);
             additionalProperties: false,
             properties: {
                 $lit: {
-                    type: 'string',
+                    type: ['string', 'boolean'],
                 },
                 $ref: {
                     type: 'array',
@@ -359694,8 +359701,11 @@ var ajv_default = /*#__PURE__*/__nccwpck_require__.n(dist_ajv);
                 $arg: {
                     type: 'string',
                 },
+                $template: {
+                    type: 'string',
+                },
                 $default: {
-                    type: ['string', 'array'],
+                    type: ['string', 'array', 'boolean'],
                 },
             },
         },
@@ -359775,7 +359785,9 @@ function __validateFeatureConfig(featurePath) {
     }
 }
 function __validateFeatureConfigData(configData) {
-    const ajv = new (ajv_default())();
+    const ajv = new (ajv_default())({
+        allowUnionTypes: true,
+    });
     const validate = ajv.compile(src_schema);
     const valid = validate(configData);
     if (!valid) {
@@ -360609,10 +360621,14 @@ function addTraceabilityStamp(context, content) {
 
 
 
+
 function render(featurePath, featureRenderPath, entity, firestartrConfig = {}, featureArgs = {}) {
     const configData = validate_validate(featurePath);
     const context = buildContext(entity, configData.args, firestartrConfig, featureArgs);
     context.config = JSON.parse(renderContent(JSON.stringify(configData), context));
+    if ('filesTemplates' in context.config) {
+        expandFiles(featurePath, configData, context);
+    }
     const output = { files: [] };
     context.config.files.forEach((file) => {
         const { src, dest } = file;
@@ -360668,8 +360684,50 @@ 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) {
+        const addToFiles = expandFilesTemplate(featurePath, tpl, context);
+        files = files.concat(addToFiles).flat(Infinity);
+    }
+    context.config.files = context.config.files.concat(files).flat(Infinity);
+}
+function expandFilesTemplate(featurePath, tplPath, context) {
+    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)
+        data.files = [];
+    return data.files.filter((file) => file);
+}
 function renderContent(template, ctx) {
     return mustache_mustache.render(template, ctx, {}, ['{{|', '|}}']);
 }
@@ -360739,7 +360797,7 @@ function loadAndValidateRenderTests(featurePath) {
         throw new Error(`render_tests.yaml is required but not found at ${file}`);
     }
     const raw = loadYaml(file);
-    const ajv = new (ajv_default())({ allErrors: true, strict: true });
+    const ajv = new (ajv_default())({ allErrors: true, strict: true, allowUnionTypes: true });
     const validate = ajv.compile(renderTestsSchema);
     const ok = validate(raw);
     if (!ok) {
@@ -367680,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}'.`);
@@ -367825,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');
@@ -367855,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}'.`);
@@ -367886,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}'.`);
@@ -367904,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);
@@ -368565,6 +368705,11 @@ const kindsWithFinalizer = [
     'FirestartrGithubOrgWebhook',
     'FirestartrGithubRepositorySecretsSection',
 ];
+const kindsWithDependants = [
+    'FirestartrDummyA',
+    'FirestartrDummyB',
+    'FirestartrGithubRepository',
+];
 /**
  * Observe whenever a new item is added, modified or deleted in a given kind
  * @param {string} pluralKind - Kind to observe
@@ -368594,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) {
@@ -368675,6 +368821,28 @@ 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)),
+        needsBlocking: (item) => {
+            if (kindsWithDependants.indexOf(item.kind) === -1) {
+                return false;
+            }
+            if (item.metadata.finalizers &&
+                item.metadata.finalizers.indexOf('foregroundDeletion') !== -1) {
+                // it will block for five seconds
+                workItem.isBlocked = true;
+                const tTimeout = setTimeout(() => {
+                    workItem.isBlocked = false;
+                }, 1000 * 5);
+                workItem.fUnblock = () => {
+                    clearTimeout(tTimeout);
+                    workItem.isBlocked = false;
+                };
+                return true;
+            }
+            else {
+                workItem.isBlocked = false;
+                return false;
+            }
+        },
     };
     workItem.process = async function* (item, operation, handler) {
         const needsUpdateSyncConditions = operation === OperationType.RENAMED ||
@@ -368703,6 +368871,7 @@ function enqueue(pluralKind, workItem, queue, compute, syncCtl, retryCtl) {
             operator_src_logger.debug(`The informer received an item with an operation type of '${operation}', which is not a specific operation.`);
         }
     };
+    workItem.isBlocked = false;
     queue(workItem);
 }
 function informer_itemPath(kind, item) {
@@ -368727,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) {
@@ -368743,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,
@@ -368768,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 () { },
@@ -368926,10 +369100,72 @@ function dummy_fWait(ms) {
     });
 }
 
+;// CONCATENATED MODULE: ../operator/src/ownership.ts
+
+
+
+async function getOwnerReferences(item) {
+    return item.metadata?.ownerReferences || [];
+}
+async function setOwnerReference(itemPath, namespace, ownerKind, ownerName, blockOwnerDeletion = true) {
+    let item = null;
+    try {
+        // we need to search for the owner's uuid
+        const owner = await getItemByItemPath(`${namespace}/${ownerKind}/${ownerName}`);
+        const ownerReference = {
+            apiVersion: owner.apiVersion,
+            kind: owner.kind,
+            name: ownerName,
+            controller: true,
+            blockOwnerDeletion,
+            uid: owner.metadata.uid,
+        };
+        // we get the item (to prevent race conditions)
+        item = await getItemByItemPath(itemPath);
+        const ownerReferences = item.metadata.ownerReferences ?? [];
+        const existingRefIndex = ownerReferences.findIndex((ref) => ref.uid === ownerReference.uid);
+        if (existingRefIndex === -1) {
+            // Reference does not exist, add it
+            ownerReferences.push(ownerReference);
+        }
+        else {
+            ownerReferences[existingRefIndex] = ownerReference;
+        }
+        await writeOwnerReferences(definitions_getPluralFromKind(item.kind), item.metadata.namespace, item, ownerReferences);
+    }
+    catch (err) {
+        operator_src_logger.error(err);
+        throw `Setting OwnerReferences to ${item.kind}/${item.metadata.name}: ${err}`;
+    }
+}
+async function writeOwnerReferences(kind, namespace, item, ownerReferences) {
+    operator_src_logger.debug(`The ctl is setting the ownerReferences for '${kind}/${item.metadata.name}' in namespace '${namespace}'.`);
+    const { kc, opts } = await ctl_getConnection();
+    const url = `${kc.getCurrentCluster().server}/apis/firestartr.dev/v1/namespaces/${namespace}/${kind}/${item.metadata.name}`;
+    opts.headers['Content-Type'] = 'application/json-patch+json';
+    opts.headers['Accept'] = '*';
+    const patch = {
+        op: 'replace',
+        path: '/metadata/ownerReferences',
+        value: ownerReferences,
+    };
+    const r = await fetch(url, {
+        method: 'PATCH',
+        headers: opts.headers,
+        body: JSON.stringify([patch]),
+    });
+    if (!r.ok) {
+        throw `Error on setOwnerReferences: ${namespace}/${kind}/${item['metadata']['name']}: ${r.statusText}`;
+    }
+    return r.json();
+}
+
 ;// CONCATENATED MODULE: ../operator/fdummies/index.ts
 
 
 
+
+
 function processFirestartrDummies(item, op, handler) {
     operator_src_logger.info(`FirestartrDummies Processor: ${op}`);
     try {
@@ -368960,11 +369196,19 @@ async function* updated(item, op, handler) {
     for await (const transition of doRun(item, op, handler)) {
         yield transition;
     }
+    await handleOwnerReferences(item, handler);
 }
 async function* created(item, op, handler) {
     for await (const transition of doRun(item, op, handler)) {
         yield transition;
     }
+    await handleOwnerReferences(item, handler);
+}
+async function handleOwnerReferences(item, handler) {
+    if ('needs' in item.spec) {
+        const needs = item.spec.needs;
+        await setOwnerReference(handler.itemPath(), item.metadata.namespace, definitions_getPluralFromKind(needs.kind), needs.name);
+    }
 }
 async function renamed() {
     throw new Error('Renamed operation not prepared');
@@ -369035,7 +369279,7 @@ async function* markedToDeletion(item, op, handler) {
             message: 'Destroying process started',
         };
         await handler.resolveReferences();
-        await processDummy(item);
+        await processDummy(item, op);
         yield {
             item,
             reason: op,
@@ -369104,7 +369348,7 @@ async function* doRun(item, op, handler) {
         };
         const deps = await handler.resolveReferences();
         operator_src_logger.info(`The dummy processor is applying and assessing dependencies for item '${item.kind}/${item.metadata.name}' with dependencies: '${deps}'.`);
-        await processDummy(item);
+        await processDummy(item, op);
         yield {
             item,
             reason: op,
@@ -369160,11 +369404,13 @@ async function* doRun(item, op, handler) {
         }
     }
 }
-async function processDummy(item) {
-    const s = item.spec?.computation?.numberOfSeconds;
-    operator_src_logger.info(`Processing dummy ${item.kind}/${item.metadata.name}: computing for ${s} seconds`);
+async function processDummy(item, op) {
+    const s = op === OperationType.MARKED_TO_DELETION
+        ? item.spec?.computation?.numberOfSecondsToDestroy
+        : item.spec?.computation?.numberOfSeconds;
+    operator_src_logger.info(`Processing dummy (op = ${op}) ${item.kind}/${item.metadata.name}: computing for ${s} seconds`);
     if (!s)
-        throw new Error('Unprocessable dummy: missing seconds section');
+        throw new Error('Unprocessable dummy: no seconds section');
     await fdummies_fWait(s * 1000);
 }
 function fdummies_fWait(ms) {
@@ -369197,7 +369443,8 @@ async function writeDownQueueStatus(queue) {
     let output = '';
     for (const workItem of queue) {
         const item = workItem.item;
-        output += `${item.kind}/${item.metadata.name} - ${workItem.workStatus} - ${workItem.operation} - (upsert ${formatElapsedTimeWithDate(workItem.upsertTime)})\n`;
+        const blockedText = workItem.isBlocked ? '[BLOCKED]' : '';
+        output += `${item.kind}/${item.metadata.name} - ${workItem.workStatus} - ${workItem.operation} ${blockedText} - (upsert ${formatElapsedTimeWithDate(workItem.upsertTime)})\n`;
     }
     return new Promise((ok, ko) => {
         external_fs_.writeFile('/tmp/queue', output, (err) => {
@@ -369278,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
 
 
@@ -369285,6 +369584,7 @@ async function deadLetterHandler(workItem) {
 
 
 
+
 const queue = [];
 const WEIGHTS = {
     RENAMED: 15,
@@ -369390,9 +369690,19 @@ async function processItem(workItem) {
  * @returns {void}
  */
 async function processItem_loop() {
-    const nextWorkItem = () => sortQueue(queue).find((w) => w.workStatus === WorkStatus.PENDING);
+    const nextWorkItem = () => sortQueue(queue)
+        .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}`;
@@ -369454,6 +369764,14 @@ async function runWorkItem(workItem) {
         return;
     try {
         const item = await workItem.getItem();
+        // we check if the workItem needs blocking
+        // if it does need it we return because we cannot
+        // process this item
+        if ('needsBlocking' in workItem.handler &&
+            workItem.handler.needsBlocking(item)) {
+            operator_src_logger.debug(`Item ${item.kind}/${item.metadata.namespace} needs blocking`);
+            return;
+        }
         workItem.workStatus = WorkStatus.PROCESSING;
         for await (const condition of workItem.process(item, workItem.operation, workItem.handler)) {
             if (workItem.handler === undefined)
@@ -369844,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;
@@ -371450,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);
@@ -371481,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>
 
@@ -371513,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>
 
@@ -371595,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>
 
@@ -371663,6 +371988,33 @@ function helperCreateCheckRunName(cmd, item) {
     return `${item.kind} - ${cmd}`;
 }
 
+;// CONCATENATED MODULE: ../operator/src/cdktf/ownership.ts
+
+
+
+const kindsWithFirestartrGithubRepositoryDependence = [
+    'FirestartrGithubRepositorySecretsSection',
+    'FirestartrGithubRepositoryFeature',
+];
+async function manageOwnershipReferences(item, handler, op) {
+    if (kindsWithFirestartrGithubRepositoryDependence.indexOf(item.kind) !== -1) {
+        await manageOwnershipReferencesForRepo(item, handler, op);
+    }
+}
+async function manageOwnershipReferencesForRepo(item, handler, op) {
+    try {
+        const repositoryTarget = item.spec?.repositoryTarget?.ref;
+        if (!repositoryTarget) {
+            throw `Item ${item.kind}/${item.metadata.namespace} is not correct: it does not have a repositoryTarget`;
+        }
+        await setOwnerReference(handler.itemPath(), item.metadata.namespace, definitions_getPluralFromKind(repositoryTarget.kind), repositoryTarget.name);
+    }
+    catch (err) {
+        operator_src_logger.error(`Handling ownership for ${item.kind}/${item.metadata.name}: ${err}`);
+        throw new Error(`Handling ownership for ${item.kind}/${item.metadata.name}: ${err}`);
+    }
+}
+
 ;// CONCATENATED MODULE: ../operator/cdktf.ts
 
 
@@ -371673,6 +372025,7 @@ function helperCreateCheckRunName(cmd, item) {
 
 
 
+
 function processOperation(item, op, handler) {
     operator_src_logger.info(`Processing operation ${op} on ${item.kind}/${item.metadata?.name}`);
     try {
@@ -371704,16 +372057,19 @@ async function* cdktf_created(item, op, handler) {
     for await (const transition of doApply(item, op, handler)) {
         yield transition;
     }
+    await manageOwnershipReferences(item, handler, op);
 }
 async function* cdktf_renamed(item, op, handler) {
     for await (const transition of doApply(item, op, handler)) {
         yield transition;
     }
+    await manageOwnershipReferences(item, handler, op);
 }
 async function* cdktf_updated(item, op, handler) {
     for await (const transition of doApply(item, op, handler)) {
         yield transition;
     }
+    await manageOwnershipReferences(item, handler, op);
 }
 async function* cdktf_retry(item, op, handler) {
     if ('deletionTimestamp' in item.metadata) {
@@ -371809,7 +372165,6 @@ async function* cdktf_markedToDeletion(item, op, handler) {
                 : {}),
         });
         const output = destroyOutput.output;
-        await tryPublishDestroy(item, output);
         yield {
             item,
             reason: op,
@@ -371822,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 {
@@ -371938,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}`);
@@ -371967,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;
@@ -373554,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,
@@ -373574,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}`);
         }
@@ -373663,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}`);
@@ -373694,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 {
@@ -373951,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 `
 
@@ -374170,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,
@@ -374196,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 },
         });
@@ -375806,6 +376184,10 @@ const crs_analyzerSubcommand = {
     },
 };
 
+;// CONCATENATED MODULE: ./package.json
+const package_namespaceObject = JSON.parse('{"i8":"1.55.0-snapshot-1"}');
+;// CONCATENATED MODULE: ../../package.json
+const package_namespaceObject_1 = {"i8":"1.54.0"};
 ;// CONCATENATED MODULE: ./src/subcommands/index.ts
 
 
@@ -375814,6 +376196,8 @@ const crs_analyzerSubcommand = {
 
 
 
+
+
 const SUBCOMMANDS = {
     import: importSubcommand,
     importer: importSubcommand,
@@ -375851,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
 
@@ -375871,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/render.d.ts

@@ -1,3 +1,4 @@
 export default function render(featurePath: string, featureRenderPath: string, entity: any, firestartrConfig?: any, featureArgs?: any): any;
 export declare function buildContext(entity: any, args: any, firestartrConfig: any, featureArgs: any): any;
+export declare function expandFiles(featurePath: string, configData: any, context: any): void;
 export declare function renderContent(template: string, ctx: any): string;

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

@@ -29,6 +29,13 @@ declare const _default: {
                         };
                     };
                 };
+                filesTemplates: {
+                    type: string;
+                    description: string;
+                    items: {
+                        type: string;
+                    };
+                };
             };
             required: string[];
             title: string;
@@ -48,7 +55,7 @@ declare const _default: {
             additionalProperties: boolean;
             properties: {
                 $lit: {
-                    type: string;
+                    type: string[];
                 };
                 $ref: {
                     type: string;
@@ -59,6 +66,9 @@ declare const _default: {
                 $arg: {
                     type: string;
                 };
+                $template: {
+                    type: string;
+                };
                 $default: {
                     type: string[];
                 };

package/build/packages/operator/src/cdktf/ownership.d.ts

@@ -0,0 +1,2 @@
+import { OperationType } from '../informer';
+export declare function manageOwnershipReferences(item: any, handler: any, op: OperationType): Promise<void>;

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/informer.d.ts

@@ -23,6 +23,8 @@ export type WorkItem = {
     process?: Function;
     upsertTime?: number;
     isDeadLetter?: boolean;
+    isBlocked?: boolean;
+    fUnblock?: Function;
 };
 type HandlerFinalizerFn = (kind: string, namespace: string, item: any | string, finalizer: string) => Promise<any>;
 type HandlerInformPlanFn = (prUrl: string, planText: string) => Promise<void>;
@@ -44,6 +46,9 @@ export type WorkItemHandler = {
     itemPath: ItemPathFn;
     error: ErrorFn;
     success: SuccessFn;
+    isBlocked?: boolean;
+    needsBlocking?: (item: any) => boolean;
+    fUnblock?: Function;
 };
 /**
  * Observe whenever a new item is added, modified or deleted in a given kind

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

@@ -0,0 +1,4 @@
+import { OwnerReference } from './types';
+export declare function getOwnerReferences(item: any): Promise<OwnerReference[]>;
+export declare function setOwnerReference(itemPath: string, namespace: string, ownerKind: string, ownerName: string, blockOwnerDeletion?: boolean): Promise<void>;
+export declare function writeOwnerReferences(kind: string, namespace: string, item: any, ownerReferences: OwnerReference[]): Promise<any>;

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/types.d.ts

@@ -0,0 +1,8 @@
+export interface OwnerReference {
+    apiVersion: string;
+    kind: string;
+    name: string;
+    uid: string;
+    controller?: boolean;
+    blockOwnerDeletion?: boolean;
+}

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.54.0",
+  "version": "1.55.0-snapshot-1",
   "private": false,
   "description": "Commandline tool",
   "main": "build/main.js",