@firestartr/cli 1.57.1-snapshot-3 → 1.58.0

package/build/index.js

@@ -346496,6 +346496,23 @@ function removeRepeatedObjectsFromArrayByProp(array, propiedad) {
     return array.filter((item) => uniqueSet.has(item[propiedad]));
 }
 
+;// CONCATENATED MODULE: ../catalog_common/src/generic/command_error.ts
+function buildCommandExecutionError(output, exitCode, command, opts = {}) {
+    const label = opts.label ?? 'Command';
+    const errorName = opts.errorName ?? 'CommandExecutionError';
+    const message = output ||
+        `${label} '${command.join(' ')}' failed with exit code ${exitCode}`;
+    return Object.assign(new Error(message), {
+        name: errorName,
+        output,
+        exitCode,
+        command,
+    });
+}
+function normalizeExitCode(code) {
+    return typeof code === 'number' ? code : -1;
+}
+
 ;// CONCATENATED MODULE: ../catalog_common/src/generic/index.ts
 
 
@@ -346506,6 +346523,7 @@ function removeRepeatedObjectsFromArrayByProp(array, propiedad) {
 
 
 
+
 /* harmony default export */ const generic = ({
     randomString: randomString,
     shuffleArray: shuffleArray,
@@ -346523,6 +346541,8 @@ function removeRepeatedObjectsFromArrayByProp(array, propiedad) {
     getFirestartrLabel: getFirestartrLabel,
     normalizeLabel: normalizeLabel,
     removeRepeatedObjectsFromArrayByProp: removeRepeatedObjectsFromArrayByProp,
+    buildCommandExecutionError: buildCommandExecutionError,
+    normalizeExitCode: normalizeExitCode,
     toMd5: toMd5,
 });
 
@@ -358161,6 +358181,9 @@ const external_node_child_process_namespaceObject = __WEBPACK_EXTERNAL_createReq
                     type: 'object',
                     properties: {
                         system: { $ref: 'firestartr.dev://common/FirestartrSystemRef' },
+                        owner: {
+                            $ref: 'firestartr.dev://common/FirestartrOwnerRef',
+                        },
                         providers: {
                             type: 'object',
                             properties: {
@@ -358171,6 +358194,7 @@ const external_node_child_process_namespaceObject = __WEBPACK_EXTERNAL_createReq
                             required: ['external_secrets'],
                         },
                     },
+                    required: ['owner'],
                 },
             ],
         },
@@ -358193,6 +358217,12 @@ const external_node_child_process_namespaceObject = __WEBPACK_EXTERNAL_createReq
                 {
                     type: 'object',
                     properties: {
+                        system: {
+                            $ref: 'firestartr.dev://common/FirestartrSystemRef',
+                        },
+                        owner: {
+                            $ref: 'firestartr.dev://common/FirestartrOwnerRef',
+                        },
                         providers: {
                             type: 'object',
                             properties: {
@@ -358202,6 +358232,7 @@ const external_node_child_process_namespaceObject = __WEBPACK_EXTERNAL_createReq
                             },
                         },
                     },
+                    required: ['owner'],
                 },
             ],
         },
@@ -365180,7 +365211,11 @@ class CatalogOrgWebhookChart extends BaseCatalogChart {
                 name: catalog_common.generic.normalizeName(`orgWebhook-${claim.name}`),
                 annotations: claim.annotations || {},
             },
-            spec: {},
+            spec: {
+                type: 'webhook',
+                owner: claim.owner || 'nobody',
+                system: claim.system,
+            },
         };
     }
     instanceApiObject(template) {
@@ -367858,14 +367893,22 @@ async function upsertFinalizer(kind, namespace, item, finalizer) {
  */
 async function unsetFinalizer(kind, namespace, item, finalizer) {
     const { kc, opts } = await ctl_getConnection();
-    const name = typeof item === 'string' ? item : item.metadata.name;
+    let itemObj;
+    if (typeof item === 'string') {
+        itemObj = await getItemByItemPath([namespace, kind, item].join('/'));
+    }
+    else {
+        itemObj = item;
+    }
+    const name = itemObj.metadata.name;
     operator_src_logger.debug(`The ctl is removing the finalizer '${finalizer}' from '${kind}/${name}' in namespace '${namespace}'.`);
     const url = `${kc.getCurrentCluster().server}/apis/firestartr.dev/v1/namespaces/${namespace}/${kind}/${name}`;
     opts.headers['Content-Type'] = 'application/json-patch+json';
     opts.headers['Accept'] = '*';
     const patch = {
-        op: 'remove',
+        op: 'replace',
         path: '/metadata/finalizers',
+        value: itemObj.metadata.finalizers.filter((f) => f !== finalizer),
     };
     const r = await fetch(url, {
         method: 'PATCH',
@@ -369031,12 +369074,25 @@ 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) => {
+        needsBlocking: (item, operation) => {
             if (kindsWithDependants.indexOf(item.kind) === -1) {
                 return false;
             }
+            // only for delete operations
+            if (operation !== OperationType.MARKED_TO_DELETION) {
+                if (operation === OperationType.RETRY) {
+                    // is the retry a delete operation?
+                    if (!('deletionTimestamp' in workItem.item.metadata)) {
+                        return false;
+                    }
+                }
+                else {
+                    return false;
+                }
+            }
             if (item.metadata.finalizers &&
-                item.metadata.finalizers.indexOf('foregroundDeletion') !== -1) {
+                (item.metadata.finalizers.indexOf('foregroundDeletion') !== -1 ||
+                    item.metadata.finalizers.indexOf('firestartr.dev/foreground-deletion') !== -1)) {
                 // it will block for five seconds
                 workItem.isBlocked = true;
                 const tTimeout = setTimeout(() => {
@@ -369317,7 +369373,7 @@ function dummy_fWait(ms) {
 async function getOwnerReferences(item) {
     return item.metadata?.ownerReferences || [];
 }
-async function setOwnerReference(itemPath, namespace, ownerKind, ownerName, blockOwnerDeletion = true) {
+async function ownership_setOwnerReference(itemPath, namespace, ownerKind, ownerName, blockOwnerDeletion = true) {
     let item = null;
     try {
         // we need to search for the owner's uuid
@@ -369417,7 +369473,7 @@ async function* created(item, op, 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);
+        await ownership_setOwnerReference(handler.itemPath(), item.metadata.namespace, definitions_getPluralFromKind(needs.kind), needs.name);
     }
 }
 async function renamed() {
@@ -369978,7 +370034,7 @@ async function runWorkItem(workItem) {
         // if it does need it we return because we cannot
         // process this item
         if ('needsBlocking' in workItem.handler &&
-            workItem.handler.needsBlocking(item)) {
+            workItem.handler.needsBlocking(item, workItem.operation)) {
             operator_src_logger.debug(`Item ${item.kind}/${item.metadata.namespace} needs blocking`);
             return;
         }
@@ -371357,7 +371413,10 @@ async function runTerraform(entity, command, stream) {
         terraformProcess.on('exit', async (code) => {
             console.log(`child process exited with code ${code}`);
             if (code !== 0) {
-                ko(output);
+                ko(catalog_common.generic.buildCommandExecutionError(output, catalog_common.generic.normalizeExitCode(code), command, {
+                    errorName: 'TerraformCommandError',
+                    label: 'Terraform command',
+                }));
             }
             else {
                 ok(output);
@@ -372020,7 +372079,7 @@ if (process.env.RUN_PROVISIONER) {
 
 
 const LAST_STATE_PR_ANNOTATION = 'firestartr.dev/last-state-pr';
-async function tryPublishApply(item, planOutput, isSuccess = true) {
+async function tryPublishApply(item, planOutput, isSuccess = true, exitCode) {
     const kind = item.kind;
     const metadataName = item.metadata?.name ?? 'unknown';
     try {
@@ -372029,7 +372088,11 @@ async function tryPublishApply(item, planOutput, isSuccess = true) {
             operator_src_logger.debug(`The user feedback for the '${kind}/${metadataName}' apply operation could not be published because the last state was not found.`);
             return;
         }
-        await publishApply(item, planOutput, isSuccess);
+        const effectiveSuccess = isSuccess && (exitCode === undefined || exitCode === 0);
+        if (isSuccess && exitCode !== undefined && exitCode !== 0) {
+            operator_src_logger.warn(`The user feedback for the '${kind}/${metadataName}' apply operation was downgraded to failure because terraform exited with code '${exitCode}'.`);
+        }
+        await publishApply(item, planOutput, effectiveSuccess);
     }
     catch (e) {
         operator_src_logger.error(`The user feedback for the '${kind}/${metadataName}' apply operation failed to publish due to an error: '${e}'.`);
@@ -372244,17 +372307,205 @@ function helperCreateCheckRunName(cmd, item) {
     return `${item.kind} - ${cmd}`;
 }
 
+;// CONCATENATED MODULE: ../operator/src/utils/index.ts
+const secretRegex = /\$\{\{ secrets\.(.*?) \}\}/g;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function getFirstNonEmptyString(...values) {
+    return values.find((value) => typeof value === 'string' && value !== '');
+}
+function replaceConfigSecrets(config, secrets) {
+    for (const key in config) {
+        if (typeof config[key] === 'object' && config[key] !== null) {
+            // If the property is an object, call this function recursively
+            replaceConfigSecrets(config[key], secrets);
+        }
+        else if (typeof config[key] === 'string') {
+            // If the property is a string and its value is equal to secrets.something,
+            // replace the value with the value of the 'something' key in the secrets object
+            config[key] = config[key].replace(secretRegex, (_, group1) => {
+                if (!secrets[group1]) {
+                    throw new Error(`Secret ${group1} not found in secrets`);
+                }
+                return secrets[group1];
+            });
+        }
+    }
+    return config;
+}
+function replaceInlineSecrets(inline, secrets) {
+    if (typeof inline !== 'string' || !inline)
+        return inline;
+    let result = inline;
+    result = result.replace(secretRegex, (_, group1) => {
+        if (!secrets[group1]) {
+            throw new Error(`Secret ${group1} not found in secrets`);
+        }
+        return secrets[group1];
+    });
+    return result;
+}
+function extractErrorDetails(error) {
+    const exitCode = isRecord(error) && typeof error.exitCode === 'number'
+        ? error.exitCode
+        : undefined;
+    if (typeof error === 'string') {
+        return { output: error, exitCode };
+    }
+    if (error instanceof Error) {
+        const errorWithOutput = error;
+        const output = getFirstNonEmptyString(errorWithOutput.output, error.message);
+        return { output: output ?? String(error), exitCode };
+    }
+    if (isRecord(error)) {
+        const output = getFirstNonEmptyString(error.output, error.message, error.error);
+        if (output !== undefined) {
+            return { output, exitCode };
+        }
+        try {
+            return { output: JSON.stringify(error), exitCode };
+        }
+        catch {
+            return { output: String(error), exitCode };
+        }
+    }
+    return { output: String(error), exitCode };
+}
+
+;// CONCATENATED MODULE: ../operator/src/ctl_collections.ts
+
+
+
+// generator function to traverse elements
+// it is async and iterable
+async function* traverseCRCollection(pluralKind, namespace, options = {}, apiGroup = 'firestartr.dev', apiVersion = 'v1') {
+    const { limit = 300 } = options; // between 250-300
+    try {
+        let continueToken = undefined;
+        const { kc, opts } = await ctl_getConnection();
+        const k8sApi = kc.makeApiClient(client_node_dist.CustomObjectsApi);
+        const apiGroup = 'firestartr.dev';
+        const apiVersion = 'v1';
+        const apiPaths = `/apis/${apiGroup}/${apiVersion}/namespaces/${namespace}/${pluralKind}`;
+        do {
+            const res = await k8sApi.listNamespacedCustomObject(apiGroup, apiVersion, namespace, pluralKind, undefined, // pretty
+            undefined, // allowWatchBookmarks
+            continueToken, // _continue
+            undefined, // fieldSelector
+            undefined, // labelSelector
+            limit);
+            const body = res.body;
+            const items = body.items || [];
+            for (const item of items) {
+                yield item;
+            }
+            continueToken = body.metadata?.continue;
+        } while (continueToken);
+    }
+    catch (err) {
+        operator_src_logger.error(`Error traversing ${namespace}/${pluralKind}: ${err}`);
+        throw new Error(`Error traversing ${namespace}/${pluralKind}: ${err}`);
+    }
+}
+
+;// CONCATENATED MODULE: ../operator/src/children.ts
+
+
+async function findCRsWithReference(kind, item) {
+    try {
+        const crChildren = [];
+        for await (const crItem of traverseCRCollection(kind, item.metadata.namespace)) {
+            if ('repositoryTarget' in crItem.spec) {
+                const repositoryTarget = crItem.spec.repositoryTarget;
+                if (repositoryTarget.ref.name === item.metadata.name &&
+                    repositoryTarget.ref.kind === item.kind) {
+                    crChildren.push(crItem);
+                }
+            }
+        }
+        return crChildren;
+    }
+    catch (err) {
+        operator_src_logger.error(`Error finding Crs with reference for ${item.kind}/${item.metadata.name}: ${err}`);
+        throw new Error(`Error finding Crs with reference for ${item.kind}/${item.metadata.name}: ${err}`);
+    }
+}
+
 ;// CONCATENATED MODULE: ../operator/src/cdktf/ownership.ts
 
 
 
+
+
 const kindsWithFirestartrGithubRepositoryDependence = [
     'FirestartrGithubRepositorySecretsSection',
     'FirestartrGithubRepositoryFeature',
 ];
+const kindsWithChildren = ['FirestartrGithubRepository'];
 async function manageOwnershipReferences(item, handler, op) {
+    /*********************************************************************************
+    // suspended due to https://github.com/prefapp/gitops-k8s/issues/1767
     if (kindsWithFirestartrGithubRepositoryDependence.indexOf(item.kind) !== -1) {
-        await manageOwnershipReferencesForRepo(item, handler, op);
+      // await manageOwnershipReferencesForRepo(item, handler, op);
+  
+    }
+     *******************************************************************************/
+    if (kindsWithFirestartrGithubRepositoryDependence.indexOf(item.kind) !== -1) {
+        // we need the parent
+        const parentItem = await getItemByItemPath([
+            item.metadata.namespace,
+            definitions_getPluralFromKind('FirestartrGithubRepository'),
+            item.spec.repositoryTarget.ref.name,
+        ].join('/'));
+        await installDependencesFinalizer(parentItem, handler, op);
+    }
+}
+async function manageOwnershipReferencesPostDeletion(item, handler, op) {
+    // We will check if the repo has still some references left
+    if (kindsWithFirestartrGithubRepositoryDependence.indexOf(item.kind) !== -1) {
+        await manageChildrenReferences(item, handler, op);
+    }
+    // if the parent is being deleted is ok to control there are no more children
+    // for preventing a stuck deletion
+    else if (kindsWithChildren.indexOf(item.kind) !== -1) {
+        await removeFinalizerIfNoMoreChildren(item, handler, op);
+    }
+}
+async function manageChildrenReferences(item, handler, op) {
+    // for now is only FirestartrGithubRepository
+    const parentItem = await getItemByItemPath([
+        item.metadata.namespace,
+        definitions_getPluralFromKind('FirestartrGithubRepository'),
+        item.spec.repositoryTarget.ref.name,
+    ].join('/'));
+    await removeFinalizerIfNoMoreChildren(parentItem, handler, op);
+}
+async function removeFinalizerIfNoMoreChildren(parentItem, handler, op) {
+    try {
+        let numberOfChildren = 0;
+        for (const child of kindsWithFirestartrGithubRepositoryDependence) {
+            const children = await findCRsWithReference(definitions_getPluralFromKind(child), parentItem);
+            numberOfChildren += children.length;
+        }
+        operator_src_logger.error(`Number of children ${numberOfChildren}`);
+        if (numberOfChildren === 0) {
+            operator_src_logger.info(`${parentItem.kind}/${parentItem.metadata.name} has no more children. Removing finalizer of foreground-deletion`);
+            await unsetFinalizer(definitions_getPluralFromKind(parentItem.kind), parentItem.metadata.namespace, parentItem, 'firestartr.dev/foreground-deletion');
+        }
+    }
+    catch (err) {
+        operator_src_logger.error(`Error managing children references in item: ${parentItem.kind}/${parentItem.metadata.name}: ${err}`);
+        throw new Error(`Error managing children references in item: ${parentItem.kind}/${parentItem.metadata.name}: ${err}`);
+    }
+}
+async function installDependencesFinalizer(item, handler, op) {
+    try {
+        await upsertFinalizer(definitions_getPluralFromKind(item.kind), item.metadata.namespace, item, 'firestartr.dev/foreground-deletion');
+    }
+    catch (err) {
+        operator_src_logger.error(`Error inserting finalizer for children dependencies ${item.kind}/${item.metadata.name}`);
+        throw new Error(`Error inserting finalizer for children dependencies ${item.kind}/${item.metadata.name}`);
     }
 }
 async function manageOwnershipReferencesForRepo(item, handler, op) {
@@ -372263,10 +372514,10 @@ async function manageOwnershipReferencesForRepo(item, handler, op) {
         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);
+        await setOwnerReference(handler.itemPath(), item.metadata.namespace, getPluralFromKind(repositoryTarget.kind), repositoryTarget.name);
     }
     catch (err) {
-        operator_src_logger.error(`Handling ownership for ${item.kind}/${item.metadata.name}: ${err}`);
+        log.error(`Handling ownership for ${item.kind}/${item.metadata.name}: ${err}`);
         throw new Error(`Handling ownership for ${item.kind}/${item.metadata.name}: ${err}`);
     }
 }
@@ -372282,6 +372533,7 @@ async function manageOwnershipReferencesForRepo(item, handler, op) {
 
 
 
+
 function processOperation(item, op, handler) {
     operator_src_logger.info(`Processing operation ${op} on ${item.kind}/${item.metadata?.name}`);
     try {
@@ -372434,17 +372686,12 @@ async function* cdktf_markedToDeletion(item, op, handler) {
             await addDestroyCommitStatus(item, 'success', 'Destroy operation completed', `Terraform Destroy ${item.metadata.name}`);
         }
         await tryPublishDestroy(item, output, true);
+        await manageOwnershipReferencesPostDeletion(item, handler, op);
         void handler.success();
     }
     catch (e) {
         error = true;
-        let errorMsg;
-        if (typeof e === 'object' && 'output' in e) {
-            errorMsg = e.output;
-        }
-        else {
-            errorMsg = e;
-        }
+        const { output: errorMsg } = extractErrorDetails(e);
         // if there is a current checkRun working
         // we close it with an error
         if (checkRunCtl)
@@ -372589,19 +372836,13 @@ async function* doApply(item, op, handler) {
             message: 'doApply',
         };
         await handler.writeTerraformOutputInTfResult(item, output);
-        await tryPublishApply(item, applyOutput?.data?.output, true);
+        await tryPublishApply(item, applyOutput?.data?.output, true, 0);
         void handler.success();
     }
     catch (e) {
         error = true;
-        let errorMsg;
-        if (typeof e === 'object' && 'output' in e) {
-            errorMsg = e.output;
-        }
-        else {
-            errorMsg = e;
-        }
-        await tryPublishApply(item, errorMsg, false);
+        const { output: errorMsg, exitCode } = extractErrorDetails(e);
+        await tryPublishApply(item, errorMsg, false, exitCode);
         // if there is a current checkRun working
         // we close it with an error
         if (checkRunCtl)
@@ -372824,7 +373065,10 @@ async function tfExec(path, args, secrets, extraArgs = ['-input=false'], stream)
             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([output, outputErrors].join(''));
+                ko(catalog_common.generic.buildCommandExecutionError([output, outputErrors].join(''), catalog_common.generic.normalizeExitCode(code), args.concat(extraArgs), {
+                    errorName: 'TerraformCommandError',
+                    label: 'Terraform command',
+                }));
             }
             else {
                 terraform_provisioner_src_logger.info(`Terraform output ${path}: ${output}`);
@@ -373767,40 +374011,6 @@ function tf_checkrun_helperCreateCheckRunName(cmd) {
     return `TFWorkspace - ${cmd}`;
 }
 
-;// CONCATENATED MODULE: ../operator/src/utils/index.ts
-const secretRegex = /\$\{\{ secrets\.(.*?) \}\}/g;
-function replaceConfigSecrets(config, secrets) {
-    for (const key in config) {
-        if (typeof config[key] === 'object' && config[key] !== null) {
-            // If the property is an object, call this function recursively
-            replaceConfigSecrets(config[key], secrets);
-        }
-        else if (typeof config[key] === 'string') {
-            // If the property is a string and its value is equal to secrets.something,
-            // replace the value with the value of the 'something' key in the secrets object
-            config[key] = config[key].replace(secretRegex, (_, group1) => {
-                if (!secrets[group1]) {
-                    throw new Error(`Secret ${group1} not found in secrets`);
-                }
-                return secrets[group1];
-            });
-        }
-    }
-    return config;
-}
-function replaceInlineSecrets(inline, secrets) {
-    if (typeof inline !== 'string' || !inline)
-        return inline;
-    let result = inline;
-    result = result.replace(secretRegex, (_, group1) => {
-        if (!secrets[group1]) {
-            throw new Error(`Secret ${group1} not found in secrets`);
-        }
-        return secrets[group1];
-    });
-    return result;
-}
-
 ;// CONCATENATED MODULE: ../operator/src/tfworkspaces/process-operation.ts
 
 
@@ -373944,15 +374154,16 @@ async function* doPlanJSONFormat(item, op, handler, setResult = function (_r) {
     }
     catch (e) {
         error = true;
+        const { output: errorMsg } = extractErrorDetails(e);
         console.error(e);
-        operator_src_logger.error(`The Terraform processor encountered an error while observing the plan for item '${item.kind}/${item.metadata.name}': '${e}'.`);
-        const summaryText = tryCreateErrorSummary('Terraform Plan failed', e);
+        operator_src_logger.error(`The Terraform processor encountered an error while observing the plan for item '${item.kind}/${item.metadata.name}': '${errorMsg}'.`);
+        const summaryText = tryCreateErrorSummary('Terraform Plan failed', errorMsg);
         if (item.metadata.annotations['firestartr.dev/last-state-pr'] || false) {
             await addPlanStatusCheck(item.metadata.annotations['firestartr.dev/last-state-pr'], summaryText, 'completed', true);
         }
         void handler.error();
-        if (e) {
-            await handler.writeTerraformOutputInTfResult(item, e);
+        if (errorMsg) {
+            await handler.writeTerraformOutputInTfResult(item, errorMsg);
         }
     }
     finally {
@@ -374201,13 +374412,7 @@ async function* process_operation_markedToDeletion(item, op, handler) {
     }
     catch (e) {
         error = true;
-        let errorMsg;
-        if (typeof e === 'object' && 'output' in e) {
-            errorMsg = e.output;
-        }
-        else {
-            errorMsg = e;
-        }
+        const { output: errorMsg } = extractErrorDetails(e);
         await tryPublishDestroy(item, errorMsg, false);
         await handler.writeTerraformOutputInTfResult(item, errorMsg);
         if (item.metadata.annotations['firestartr.dev/last-state-pr'] || false) {
@@ -374324,21 +374529,15 @@ async function* process_operation_doApply(item, op, handler) {
             message: 'doApply',
         };
         await handler.writeTerraformOutputInTfResult(item, output);
-        await tryPublishApply(item, applyOutput, true);
+        await tryPublishApply(item, applyOutput, true, 0);
         handler.success();
     }
     catch (e) {
         error = true;
-        let errorMsg;
-        if (typeof e === 'object' && 'output' in e) {
-            errorMsg = e.output;
-        }
-        else {
-            errorMsg = e;
-        }
+        const { output: errorMsg, exitCode } = extractErrorDetails(e);
         checkRunCtl.fnOnError(errorMsg);
         console.error(e);
-        await tryPublishApply(item, errorMsg, false);
+        await tryPublishApply(item, errorMsg, false, exitCode);
         operator_src_logger.error(`The Terraform processor encountered an error during operation '${op}' for item '${item.kind}/${item.metadata.name}': '${e}'.`);
         handler.error();
         if (errorMsg) {
@@ -374836,18 +375035,19 @@ async function* doPlanPlainTextFormat(item, op, handler, action) {
     }
     catch (e) {
         error = true;
+        const { output: errorMsg } = extractErrorDetails(e);
         const { prNumber, repo, org } = extractPrInfo(item, 'firestartr.dev/pull-request-plan');
-        await publishPlan(item, JSON.stringify(e), prNumber, repo, org, false);
+        await publishPlan(item, errorMsg, prNumber, repo, org, false);
         operator_src_logger.error('TFWORKSPACE_PROCESSOR_PLAN_OBSERVING_ERROR', {
             metadata: { item, error: e },
         });
-        const summaryText = tryCreateErrorSummary('Terraform Plan failed', e);
+        const summaryText = tryCreateErrorSummary('Terraform Plan failed', errorMsg);
         if (item.metadata.annotations['firestartr.dev/last-state-pr'] || false) {
             await addPlanStatusCheck(item.metadata.annotations['firestartr.dev/last-state-pr'], summaryText, 'completed', true);
         }
         void handler.error();
-        if (e) {
-            await handler.writeTerraformOutputInTfResult(item, e);
+        if (errorMsg) {
+            await handler.writeTerraformOutputInTfResult(item, errorMsg);
         }
     }
     finally {
@@ -374961,13 +375161,14 @@ async function* processOperationPlan_doPlanJSONFormat(item, op, handler, action)
     }
     catch (e) {
         error = true;
+        const { output: errorMsg } = extractErrorDetails(e);
         console.error(e);
         operator_src_logger.error('TFWORKSPACE_PROCESSOR_PLAN_DO_PLAN_ERROR', {
             metadata: { item, error: e },
         });
         void handler.error();
-        if (e) {
-            await handler.writeTerraformOutputInTfResult(item, e);
+        if (errorMsg) {
+            await handler.writeTerraformOutputInTfResult(item, errorMsg);
         }
     }
     finally {
@@ -375379,6 +375580,7 @@ function waitForFile(filePath) {
 
 
 
+
 var FileStatus;
 (function (FileStatus) {
     FileStatus["DELETED"] = "removed";
@@ -375436,16 +375638,7 @@ async function tfWorkspacePlan(opts) {
     }
     catch (e) {
         console.error(e);
-        let message = '';
-        if (e && typeof e === 'string') {
-            message = e;
-        }
-        else if (e && typeof e === 'object' && e.message) {
-            message = e.message;
-        }
-        else {
-            message = 'An unknown error occurred';
-        }
+        const { output: message } = extractErrorDetails(e);
         fDebug(`Error: ${message}`, 'error');
         await addPlanStatusCheck(pull, message, 'completed', true);
         fDebug('Publishing plan');
@@ -376444,9 +376637,9 @@ const crs_analyzerSubcommand = {
 };
 
 ;// CONCATENATED MODULE: ./package.json
-const package_namespaceObject = JSON.parse('{"i8":"1.57.1-snapshot-3"}');
+const package_namespaceObject = {"i8":"1.58.0"};
 ;// CONCATENATED MODULE: ../../package.json
-const package_namespaceObject_1 = {"i8":"1.57.0"};
+const package_namespaceObject_1 = {"i8":"1.58.0"};
 ;// CONCATENATED MODULE: ./src/subcommands/index.ts
 
 

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

@@ -39,6 +39,8 @@ declare const _default: {
         getFirestartrLabel: typeof import("./src/generic/labels").getFirestartrLabel;
         normalizeLabel: typeof import("./src/generic/labels").normalizeLabel;
         removeRepeatedObjectsFromArrayByProp: typeof import("./src/generic/arrays").removeRepeatedObjectsFromArrayByProp;
+        buildCommandExecutionError: typeof import("./src/generic/command_error").buildCommandExecutionError;
+        normalizeExitCode: typeof import("./src/generic/command_error").normalizeExitCode;
         toMd5: typeof import("./src/generic/nomicon").toMd5;
     };
     types: {

package/build/packages/catalog_common/src/generic/command_error.d.ts

@@ -0,0 +1,10 @@
+export declare function buildCommandExecutionError(output: string, exitCode: number, command: Array<string>, opts?: {
+    errorName?: string;
+    label?: string;
+}): Error & {
+    name: string;
+    output: string;
+    exitCode: number;
+    command: string[];
+};
+export declare function normalizeExitCode(code: number | null): number;

package/build/packages/catalog_common/src/generic/index.d.ts

@@ -7,6 +7,7 @@ import { normalizeName, transformKeysToCamelCase } from './name';
 import { getFirestartrAnnotation, getOwnerRepoPrNumberFromAnnotationValue, getPrLinkFromAnnotationValue } from './annotations';
 import { getFirestartrLabel, normalizeLabel } from './labels';
 import { removeRepeatedObjectsFromArrayByProp } from './arrays';
+import { buildCommandExecutionError, normalizeExitCode } from './command_error';
 declare const _default: {
     randomString: typeof randomString;
     shuffleArray: typeof shuffleArray;
@@ -24,6 +25,8 @@ declare const _default: {
     getFirestartrLabel: typeof getFirestartrLabel;
     normalizeLabel: typeof normalizeLabel;
     removeRepeatedObjectsFromArrayByProp: typeof removeRepeatedObjectsFromArrayByProp;
+    buildCommandExecutionError: typeof buildCommandExecutionError;
+    normalizeExitCode: typeof normalizeExitCode;
     toMd5: typeof toMd5;
 };
 export default _default;

package/build/packages/cdk8s_renderer/src/charts/catalog/orgWebhookChart.d.ts

@@ -10,7 +10,11 @@ export declare class CatalogOrgWebhookChart extends BaseCatalogChart {
                 [key: string]: string;
             };
         };
-        spec: {};
+        spec: {
+            type: string;
+            owner: string;
+            system: string;
+        };
     };
     instanceApiObject(template: any): ApiObject;
     gvk(): GroupVersionKind;

package/build/packages/cdk8s_renderer/src/claims/base/orgWebhook.d.ts

@@ -2,6 +2,8 @@ import { IClaim } from '../base';
 export interface IOrgWebhookClaim extends IClaim {
     org: string;
     displayName: string;
+    system?: string;
+    owner: string;
     providers: object;
 }
 export declare const schema = "firestartr.dev://common/OrgWebhookClaim";

package/build/packages/cdk8s_renderer/src/claims/base/schemas/index.d.ts

@@ -1045,12 +1045,16 @@ declare const schemas: {
                     $ref: string;
                     type?: undefined;
                     properties?: undefined;
+                    required?: undefined;
                 } | {
                     type: string;
                     properties: {
                         system: {
                             $ref: string;
                         };
+                        owner: {
+                            $ref: string;
+                        };
                         providers: {
                             type: string;
                             properties: {
@@ -1061,6 +1065,7 @@ declare const schemas: {
                             required: string[];
                         };
                     };
+                    required: string[];
                     $ref?: undefined;
                 })[];
             };
@@ -1078,9 +1083,16 @@ declare const schemas: {
                     $ref: string;
                     type?: undefined;
                     properties?: undefined;
+                    required?: undefined;
                 } | {
                     type: string;
                     properties: {
+                        system: {
+                            $ref: string;
+                        };
+                        owner: {
+                            $ref: string;
+                        };
                         providers: {
                             type: string;
                             properties: {
@@ -1090,6 +1102,7 @@ declare const schemas: {
                             };
                         };
                     };
+                    required: string[];
                     $ref?: undefined;
                 })[];
             };

package/build/packages/cdk8s_renderer/src/claims/base/schemas/orgwebhook.schema.d.ts

@@ -11,9 +11,16 @@ declare const _default: {
                 $ref: string;
                 type?: undefined;
                 properties?: undefined;
+                required?: undefined;
             } | {
                 type: string;
                 properties: {
+                    system: {
+                        $ref: string;
+                    };
+                    owner: {
+                        $ref: string;
+                    };
                     providers: {
                         type: string;
                         properties: {
@@ -23,6 +30,7 @@ declare const _default: {
                         };
                     };
                 };
+                required: string[];
                 $ref?: undefined;
             })[];
         };

package/build/packages/cdk8s_renderer/src/claims/base/schemas/secrets.schema.d.ts

@@ -11,12 +11,16 @@ declare const _default: {
                 $ref: string;
                 type?: undefined;
                 properties?: undefined;
+                required?: undefined;
             } | {
                 type: string;
                 properties: {
                     system: {
                         $ref: string;
                     };
+                    owner: {
+                        $ref: string;
+                    };
                     providers: {
                         type: string;
                         properties: {
@@ -27,6 +31,7 @@ declare const _default: {
                         required: string[];
                     };
                 };
+                required: string[];
                 $ref?: undefined;
             })[];
         };

package/build/packages/cdk8s_renderer/src/claims/base/secrets.d.ts

@@ -5,5 +5,6 @@ export interface ISecretsClaim extends IClaim {
     system: string;
     name: string;
     providers: any;
+    owner: `${string}:${string}`;
 }
 export declare const schema = "firestartr.dev://common/SecretsClaim";

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

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

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

@@ -0,0 +1 @@
+export declare function findCRsWithReference(kind: string, item: any): Promise<any[]>;

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

@@ -0,0 +1,3 @@
+export declare function traverseCRCollection<T = any>(pluralKind: string, namespace: string, options?: {
+    limit?: number;
+}, apiGroup?: string, apiVersion?: string): AsyncGenerator<T>;

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

@@ -48,7 +48,7 @@ export type WorkItemHandler = {
     error: ErrorFn;
     success: SuccessFn;
     isBlocked?: boolean;
-    needsBlocking?: (item: any) => boolean;
+    needsBlocking?: (item: any, operation: OperationType) => boolean;
     fUnblock?: Function;
 };
 /**

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

@@ -1,4 +1,4 @@
-export declare function tryPublishApply(item: any, planOutput: string, isSuccess?: boolean): Promise<void>;
+export declare function tryPublishApply(item: any, planOutput: string, isSuccess?: boolean, exitCode?: number): Promise<void>;
 export declare function tryPublishDestroy(item: any, destroyOutput: string, isSuccess?: boolean): Promise<void>;
 export declare function publishApply(item: any, applyOutput: string, isSuccess?: boolean): Promise<void>;
 export declare function tryCreateErrorSummary(title: string, errorMsg: string): string;

package/build/packages/operator/src/utils/index.d.ts

@@ -1,2 +1,6 @@
 export declare function replaceConfigSecrets(config: any, secrets: any): any;
 export declare function replaceInlineSecrets(inline: string, secrets: any): string;
+export declare function extractErrorDetails(error: unknown): {
+    output: string;
+    exitCode?: number;
+};

package/package.json

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