@firestartr/cli 1.47.0 → 1.48.1-snapshot-0

package/build/index.js

@@ -288941,14 +288941,131 @@ var external_path_ = __nccwpck_require__(71017);
 var external_path_default = /*#__PURE__*/__nccwpck_require__.n(external_path_);
 // EXTERNAL MODULE: ../../node_modules/yaml/dist/index.js
 var yaml_dist = __nccwpck_require__(8447);
-// EXTERNAL MODULE: ../../node_modules/debug/src/index.js
-var src = __nccwpck_require__(67984);
-var src_default = /*#__PURE__*/__nccwpck_require__.n(src);
+// EXTERNAL MODULE: ../../node_modules/winston/lib/winston.js
+var winston = __nccwpck_require__(66752);
+var winston_default = /*#__PURE__*/__nccwpck_require__.n(winston);
+;// CONCATENATED MODULE: ../catalog_common/src/logger/utils.ts
+// https://siderite.dev/blog/jsonstringify-with-circular-references.html/#at2011170946
+function fixCircularReferences(o) {
+    const weirdTypes = [
+        Int8Array,
+        Uint8Array,
+        Uint8ClampedArray,
+        Int16Array,
+        Uint16Array,
+        Int32Array,
+        Uint32Array,
+        BigInt64Array,
+        BigUint64Array,
+        Float32Array,
+        Float64Array,
+        ArrayBuffer,
+        SharedArrayBuffer,
+        DataView,
+    ];
+    const defs = new Map();
+    return (k, v) => {
+        if (k && v === o) {
+            return `[${String(k)} is the same as original object]`;
+        }
+        if (v === undefined || v === null) {
+            return v;
+        }
+        // Check for the Timeout constructor. This will also catch TimersList indirectly
+        // since TimersList is part of the circular structure *of* a Timeout object.
+        if (v && v.constructor && v.constructor.name === 'Timeout') {
+            return '[Node.js internal timer object]';
+        }
+        // An alternative check could be `v instanceof Timeout` but the constructor name
+        // check is more reliable for these internal types.
+        const weirdType = weirdTypes.find((t) => v instanceof t);
+        if (weirdType) {
+            return weirdType.toString();
+        }
+        if (typeof v === 'function') {
+            return v.toString();
+        }
+        if (v && typeof v === 'object') {
+            const def = defs.get(v);
+            if (def) {
+                return `[${String(k)} is the same as ${def}]`;
+            }
+            defs.set(v, String(k));
+        }
+        return v;
+    };
+}
+
+;// CONCATENATED MODULE: ../catalog_common/src/logger/logger.ts
+
+
+const validLogLevels = [
+    'error',
+    'warn',
+    'info',
+    'debug',
+    'verbose',
+    'silly',
+];
+let initiated = false;
+let logger = null;
+// Type guard to check if a value is a valid LogLevel
+function isValidLogLevel(level) {
+    return (typeof level === 'string' && validLogLevels.includes(level));
+}
+function initLogger() {
+    if (initiated)
+        return;
+    const logLevel = process.env.LOG_LEVEL && isValidLogLevel(process.env.LOG_LEVEL)
+        ? process.env.LOG_LEVEL
+        : 'info';
+    logger = winston_default().createLogger({
+        level: logLevel,
+        exitOnError: false,
+        format: winston.format.combine(winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }), winston.format.json()),
+        transports: [
+            new winston.transports.Console({
+                level: logLevel,
+            }),
+        ],
+    });
+    initiated = true;
+}
+function doLog(level, args) {
+    initLogger();
+    const [message, data] = args;
+    let finalMessage = message;
+    if (data) {
+        const fx = fixCircularReferences(data.metadata);
+        try {
+            finalMessage =
+                finalMessage + ' | ' + JSON.stringify(data?.metadata, fx, 2);
+        }
+        catch (err) {
+            console.error(`Serializing ${message}: ${err}`);
+            return;
+        }
+    }
+    logger[level].apply(logger, [finalMessage]);
+}
+const logger_log = {
+    error: (...args) => doLog('error', args),
+    warn: (...args) => doLog('warn', args),
+    info: (...args) => doLog('info', args),
+    debug: (...args) => doLog('debug', args),
+    verbose: (...args) => doLog('verbose', args),
+    silly: (...args) => doLog('silly', args),
+};
+/* harmony default export */ const logger_logger = (logger_log);
+
+;// CONCATENATED MODULE: ../catalog_common/src/logger/index.ts
+
+/* harmony default export */ const src_logger = (logger_logger);
+
 ;// CONCATENATED MODULE: ../catalog_common/src/io/common.ts
 
 
 
-const messageLog = src_default()('firestartr:catalog_common:io:common');
 const ComponentPaths = (/* unused pure expression or super */ null && ([
     'apiVersion',
     'kind',
@@ -289033,25 +289150,25 @@ function transformKind(kind) {
     }
 }
 function getPath(kind, name, catalogPath) {
-    messageLog(`Getting path for kind ${kind} and name ${name} in catalog path ${catalogPath}`);
+    src_logger.debug(`Getting path for kind ${kind} and name ${name} in catalog path ${catalogPath}`);
     return external_path_.join(catalogPath, transformKind(kind), name + '.yaml');
 }
 function getKindPath(kind, catalogPath) {
-    messageLog(`Getting path for kind ${kind} in catalog path ${catalogPath}`);
+    src_logger.debug(`Getting path for kind ${kind} in catalog path ${catalogPath}`);
     return external_path_.join(catalogPath, transformKind(kind));
 }
 function fromYaml(data) {
     const result = yaml_dist.parse(data);
-    messageLog('Loading YAML data: %O', result);
+    src_logger.debug('Loading YAML data: %O', result);
     return result;
 }
 function toYaml(data, opts = {}) {
-    messageLog('opts', opts);
+    src_logger.debug('opts', opts);
     const result = yaml_dist.stringify(data);
     return result;
 }
 function dumpYaml(data) {
-    messageLog('Dumping object data to YAML %O', data);
+    src_logger.debug('Dumping object data to YAML %O', data);
     return yaml_dist.stringify(data);
 }
 
@@ -289059,7 +289176,6 @@ function dumpYaml(data) {
 var external_child_process_ = __nccwpck_require__(32081);
 ;// CONCATENATED MODULE: ../catalog_common/src/generic/random.ts
 
-const random_messageLog = src_default()('firestartr:catalog_common:generic:random');
 function randomString(length = 10) {
     let result = '';
     const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
@@ -289069,7 +289185,7 @@ function randomString(length = 10) {
         result += characters.charAt(Math.floor(Math.random() * charactersLength));
         counter += 1;
     }
-    random_messageLog('Generated random string %s', result);
+    src_logger.debug(`Generated random string ${result}`);
     return result;
 }
 function shuffleArray(array) {
@@ -289104,17 +289220,16 @@ function shuffleObject(obj, shuffleArrays = false) {
 
 
 
-const clone_catalog_messageLog = src_default()('firestartr:catalog_common:io:clone_catalog');
 function cloneCatalog(catalogPath, dest = _calculateRandomDestination()) {
-    clone_catalog_messageLog(`Cloning catalog from ${catalogPath} to ${dest}`);
+    src_logger.info(`Cloning catalog from ${catalogPath} to ${dest}`);
     return new Promise((ok, ko) => {
         (0,external_child_process_.exec)(`cp -a ${catalogPath} ${dest}`, (error, _stdout, _stderr) => {
             if (error) {
-                clone_catalog_messageLog(`Error cloning catalog: ${error.message}`);
+                src_logger.error(`Error cloning catalog: ${error.message}`);
                 return ko(error.message);
             }
             else {
-                clone_catalog_messageLog(`Catalog cloned to successfully to ${dest}`);
+                src_logger.info(`Catalog cloned to successfully to ${dest}`);
                 return ok(dest);
             }
         });
@@ -289133,29 +289248,28 @@ var external_fs_default = /*#__PURE__*/__nccwpck_require__.n(external_fs_);
 
 
 
-const write_messageLog = src_default()('firestartr:catalog_common:io:write');
 function writeEntity(entity, path) {
     try {
         entity['metadata']['annotations']['fire-starter.dev/timestamp'] =
             Math.floor(Date.now() / 1000).toString();
         //If we have an status, we remove it
-        write_messageLog(`Writing to catalog ${path} entity %O`, entity);
+        src_logger.debug(`Writing to catalog ${path} entity ${entity}`);
         external_fs_.writeFileSync(getPath(entity['kind'], entity['metadata']['name'], path), dumpYaml(entity));
     }
     catch (err) {
-        write_messageLog('Error writing entity, error %O', err);
+        src_logger.error(`Error writing entity '${entity.kind}', error ${err}`);
         throw `writeEntity: ${entity.kind} ${err}`;
     }
 }
 function writeClaim(claim, claimsPath) {
     try {
         const kindFolder = `${claim['kind']}s`.toLowerCase().replace('claim', '');
-        write_messageLog(`Writing to gitops ${claimsPath}/${kindFolder} claim %O`, claim);
+        src_logger.debug(`Writing to gitops ${claimsPath}/${kindFolder} claim ${claim}`);
         external_fs_.mkdirSync(external_path_.join(claimsPath, kindFolder), { recursive: true });
         external_fs_.writeFileSync(getPathClaim(claim['kind'], claim['name'], claimsPath), dumpYaml(claim));
     }
     catch (err) {
-        write_messageLog('Error writing claim, error %O', err);
+        src_logger.error(`Error writing claim, error ${err}`);
         throw `writeClaim: ${claim.kind} ${err}`;
     }
 }
@@ -289172,7 +289286,7 @@ function writeYamlFile(fileName, data, pathFile = '/tmp') {
         external_fs_.writeFileSync(external_path_.join(pathFile, fileName), dumpYaml(data));
     }
     catch (err) {
-        write_messageLog('Error writing yaml file, error %O', err);
+        src_logger.error(`Error writing yaml file, error ${err}`);
         throw `writeYamlFile: ${fileName} ${err}`;
     }
 }
@@ -289181,23 +289295,23 @@ function getPathClaim(kind, name, claimsPath) {
 }
 function renameEntity(entity, catalogPath, oldname) {
     try {
-        write_messageLog('Renaming oldname %s in %O', oldname, entity);
+        src_logger.debug(`Renaming oldname ${oldname} in ${entity}`);
         const oldPath = getPath(entity.kind, oldname, catalogPath);
         const newPath = getPath(entity.kind, entity.metadata.name, catalogPath);
         external_fs_.renameSync(oldPath, newPath);
     }
     catch (err) {
-        write_messageLog('Error writing entity, error %O', err);
+        src_logger.error(`Error writing entity, error ${err}`);
         throw `renameEntity: ${entity.kind} ${err}`;
     }
 }
 function removeEntity(entity, catalogPath) {
     try {
-        write_messageLog(`Removing entity ${entity.kind}/${entity.metadata.name} in catalog ${catalogPath}`);
+        src_logger.debug(`Removing entity ${entity.kind}/${entity.metadata.name} in catalog ${catalogPath}`);
         external_fs_.rmSync(getPath(entity.kind, entity.metadata.name, catalogPath));
     }
     catch (err) {
-        write_messageLog(`Error removing entity ${entity.kind}/${entity.metadata.name} in catalog ${catalogPath}: ${err}`);
+        src_logger.error(`Error removing entity ${entity.kind}/${entity.metadata.name} in catalog ${catalogPath}: ${err}`);
         throw `removeEntity: ${entity.kind} ${err}`;
     }
 }
@@ -289213,21 +289327,21 @@ function moveFile(oldPath, newPath) {
     external_fs_.cpSync(oldPath, newPath);
     external_fs_.rmSync(oldPath);
 }
-function writeFunctionLog(functionName, log) {
+function writeFunctionLog(functionName, logStream) {
     try {
-        external_fs_.writeFileSync(external_path_.join('/tmp', `${functionName}.${randomString(5)}.log`), log + '\n');
+        external_fs_.writeFileSync(external_path_.join('/tmp', `${functionName}.${randomString(5)}.log`), logStream + '\n');
     }
     catch (err) {
-        write_messageLog('Error writing log, error %O', err);
+        src_logger.error(`Error writing log, error ${err}`);
         throw `writeLog: ${functionName} ${err}`;
     }
 }
-function writeLogFile(fileName, log) {
+function writeLogFile(fileName, logStream) {
     try {
-        external_fs_.appendFileSync(external_path_.join('/tmp', fileName + '.log'), log + '\n');
+        external_fs_.appendFileSync(external_path_.join('/tmp', fileName + '.log'), logStream + '\n');
     }
     catch (err) {
-        write_messageLog('Error writing log, error %O', err);
+        src_logger.error(`Error writing log, error ${err}`);
         throw `writeLog: ${fileName} ${err}`;
     }
 }
@@ -289237,7 +289351,6 @@ function writeLogFile(fileName, log) {
 
 
 
-const read_messageLog = src_default()('firestartr:catalog_common:io:read');
 function readEntity(kind, name, catalogPaths) {
     try {
         if (typeof catalogPaths === 'string') {
@@ -289246,7 +289359,7 @@ function readEntity(kind, name, catalogPaths) {
         let data = false;
         for (const catalogPath of catalogPaths) {
             try {
-                read_messageLog(`Reading entity ${kind}/${name} from catalog ${catalogPath}`);
+                src_logger.debug(`Reading entity ${kind}/${name} from catalog ${catalogPath}`);
                 const entityPath = getPath(kind, name, catalogPath);
                 if (external_fs_.existsSync(entityPath)) {
                     if (data) {
@@ -289256,7 +289369,7 @@ function readEntity(kind, name, catalogPaths) {
                 }
             }
             catch (err) {
-                read_messageLog('readEntity: cached error %s', err);
+                src_logger.debug('readEntity: cached error %s', err);
                 if (err === 'DUPLICATED') {
                     throw `Error reading entity: Duplicated ${kind}/${name} in ${catalogPaths.join(', ')}`;
                 }
@@ -289268,7 +289381,7 @@ function readEntity(kind, name, catalogPaths) {
         return fromYaml(data);
     }
     catch (err) {
-        read_messageLog(err);
+        src_logger.error(err);
         throw `readEntity->: ${kind}/${name}: ${err}`;
     }
 }
@@ -289276,13 +289389,13 @@ function listByKind(kind, catalogPaths, callback, exclude = []) {
     if (typeof catalogPaths === 'string') {
         catalogPaths = [catalogPaths];
     }
-    read_messageLog('CATALOGS_PATHS_ %O', catalogPaths);
+    src_logger.debug(`CATALOGS_PATHS_ ${catalogPaths}`);
     const list = [];
     catalogPaths.forEach((catalogPath) => {
         list.push(...external_fs_.readdirSync(getKindPath(kind, catalogPath)));
     });
-    read_messageLog('LIST_ %O', list);
-    read_messageLog(`Listing entities of kind ${kind} from catalogs`);
+    src_logger.debug(`LIST_ ${list}`);
+    src_logger.debug(`Listing entities of kind ${kind} from catalogs`);
     return list
         .filter((file) => file.match(/\.yaml$/))
         .filter((file) => exclude.indexOf(file.replace(/\.yaml/, '')) === -1)
@@ -290213,6 +290326,9 @@ class CsvWriter {
 }
 /* harmony default export */ const csv_generator = (CsvWriter);
 
+// EXTERNAL MODULE: ../../node_modules/debug/src/index.js
+var src = __nccwpck_require__(67984);
+var src_default = /*#__PURE__*/__nccwpck_require__.n(src);
 ;// CONCATENATED MODULE: ../catalog_common/src/generic/logger.ts
 
 
@@ -290275,9 +290391,8 @@ var lodash_default = /*#__PURE__*/__nccwpck_require__.n(lodash);
 
 
 const { camelCase } = (lodash_default());
-const name_log = src_default()('firestartr:catalog_common:generic:name');
 function normalizeName(name) {
-    name_log('Normalizing name %s', name);
+    src_logger.debug(`Normalizing name ${name}`);
     return name.replace(/[^a-z0-9]/gi, '-').toLowerCase();
 }
 function transformKeysToCamelCase(obj) {
@@ -290618,7 +290733,6 @@ const ExternalSecretsApiGroup = 'external-secrets.io';
 
 ;// CONCATENATED MODULE: ../catalog_common/src/environment/index.ts
 
-const environment_messageLog = src_default()('firestartr:catalog_common:environment');
 function getFromEnvironment(envVar) {
     return process.env[envVar];
 }
@@ -290636,7 +290750,7 @@ function getFromEnvironmentAsBoolean(envVar) {
 }
 function checkExistOnEnvironment(envVar) {
     const environmentValue = getFromEnvironment(envVar);
-    environment_messageLog(`Checking if environment variable ${envVar} exists: ${environmentValue}`);
+    src_logger.debug(`Checking if environment variable ${envVar} exists: ${environmentValue}`);
     if (!environmentValue || environmentValue === '') {
         return false;
     }
@@ -290682,30 +290796,29 @@ const fullMembersTeam = getFromEnvironmentWithDefault(envVars.fullOrgGroup, `${o
 ;// CONCATENATED MODULE: ../catalog_common/src/features/tarballs.ts
 
 
-const tarballs_messageLog = src_default()('firestartr:catalog_common:features:tarballs');
 function getFeatureZipDownloadPath(featureName, version, owner, repo) {
     const featureDownloadPath = `/tmp/${basicFeaturePath(featureName, version, owner, repo)}-zipball.zip`;
-    tarballs_messageLog('Feature tarball download path %s', featureDownloadPath);
+    src_logger.debug(`Feature tarball download path ${featureDownloadPath}`);
     return featureDownloadPath;
 }
 function removeFeatureTarball(featureName, version, owner, repo) {
     const featurePath = getFeatureZipDownloadPath(featureName, version, owner, repo);
-    tarballs_messageLog('Removing feature tarball %s', featurePath);
+    src_logger.debug(`Removing feature tarball ${featurePath}`);
     external_fs_.unlinkSync(featurePath);
-    tarballs_messageLog(`Removed tarball for feature ${featureName} and version ${version}: ${featurePath}`);
+    src_logger.debug(`Removed tarball for feature ${featureName} and version ${version}: ${featurePath}`);
 }
 function featureTarballExists(featureName, version, owner, repo) {
     const featurePath = getFeatureZipDownloadPath(featureName, version, owner, repo);
     const exists = external_fs_.existsSync(featurePath);
-    tarballs_messageLog(`Tarball ${featurePath} exists? ${exists}`);
+    src_logger.debug(`Tarball ${featurePath} exists? ${exists}`);
     return exists;
 }
 function getFeaturesExtractPath(featureName, version, owner, repo, options = {}) {
     const { createIfNotExists } = options;
     const extractPath = `/tmp/${basicFeaturePath(featureName, version, owner, repo)}-extract`;
-    tarballs_messageLog('Extract path %s', extractPath);
+    src_logger.debug(`Extract path ${extractPath}`);
     if (createIfNotExists && !external_fs_.existsSync(extractPath)) {
-        tarballs_messageLog('Extract path %s does not exist, creating', extractPath);
+        src_logger.debug(`Extract path ${extractPath} does not exist, creating`);
         external_fs_.mkdirSync(extractPath, { recursive: true });
     }
     return extractPath;
@@ -290722,17 +290835,16 @@ function trasformLeg(leg) {
 
 
 
-const features_io_messageLog = src_default()('firestartr:catalog_common:features:features_io');
 function getFeatureRenderedPathForEntity(entity, featureName, basePath = '/tmp') {
     const entityFolderName = `${entity.metadata.name}`.toLowerCase();
     return external_path_default().join(basePath, entityFolderName, featureName);
 }
 function getFeatureRenderedConfigForComponent(entity, featureName, basePath = '/tmp/features') {
-    features_io_messageLog('Getting rendered config for component %s and feature %s', entity.name, featureName);
+    src_logger.info(`Getting rendered config for component ${entity.name}and feature ${featureName}`);
     const workdir = getFeatureRenderedPathForEntity(entity, featureName, basePath);
     const config = JSON.parse(external_fs_.readFileSync(`${workdir}/output.json`, { encoding: 'utf8' }));
-    features_io_messageLog('Feature output: %O', config);
-    features_io_messageLog(`Rendered feature ${featureName} for component ${entity.name}. Result: ${(JSON.stringify, config)}`);
+    src_logger.debug(`Feature output: ${config}`);
+    src_logger.debug(`Rendered feature ${featureName} for component ${entity.name}. Result: ${(JSON.stringify, config)}`);
     return config;
 }
 
@@ -290746,7 +290858,6 @@ function getFeatureRenderedConfigForComponent(entity, featureName, basePath = '/
 
 ;// CONCATENATED MODULE: ../catalog_common/src/policies/policies.ts
 
-const policies_log = src_default()('firestartr:catalog_common:policies');
 const FIRESTARTR_POLICIES = [
     {
         name: 'full-control',
@@ -290785,17 +290896,17 @@ function getPolicyByName(policyName) {
     return FIRESTARTR_POLICIES.find((p) => p.name === policyName || p.aliases.includes(policyName));
 }
 function policiesAreCompatible(syncPolicy, generalPolicy) {
-    policies_log('Validating policy compatibility: %s %s', syncPolicy, generalPolicy);
+    src_logger.debug('Validating policy compatibility: %s %s', syncPolicy, generalPolicy);
     const syncPolicyWeight = getPolicyByName(syncPolicy)?.weight;
     const generalPolicyWeight = getPolicyByName(generalPolicy)?.weight;
     if (!syncPolicyWeight || !generalPolicyWeight) {
         throw new Error(`Policy ${syncPolicy} or ${generalPolicy} not found`);
     }
     if (generalPolicyWeight >= syncPolicyWeight) {
-        policies_log('Policies %s %s are compatible', syncPolicy, generalPolicy);
+        src_logger.debug('Policies %s %s are compatible', syncPolicy, generalPolicy);
         return true;
     }
-    policies_log('Policies %s %s are not compatible', syncPolicy, generalPolicy);
+    src_logger.debug('Policies %s %s are not compatible', syncPolicy, generalPolicy);
     return false;
 }
 
@@ -290815,6 +290926,7 @@ function policiesAreCompatible(syncPolicy, generalPolicy) {
 
 
 
+
 /* harmony default export */ const catalog_common = ({
     io: io,
     generic: generic,
@@ -290823,6 +290935,7 @@ function policiesAreCompatible(syncPolicy, generalPolicy) {
     defaults: defaults,
     features: features,
     policies: policies,
+    logger: logger_logger,
 });
 
 ;// CONCATENATED MODULE: ../../node_modules/universal-user-agent/index.js
@@ -297369,13 +297482,16 @@ async function getOctokitFromPat(envVar) {
 }
 /* harmony default export */ const src_auth = ({ getOctokitForOrg });
 
+;// CONCATENATED MODULE: ../github/src/logger.ts
+
+/* harmony default export */ const github_src_logger = (catalog_common.logger);
+
 ;// CONCATENATED MODULE: ../github/src/organization.ts
 
 
-const organization_messageLog = src_default()('firestartr:github:organization');
 const defaultPerPage = 100;
 async function getRepositoryList(org, perPageEntries = defaultPerPage) {
-    organization_messageLog(`Getting repository list for ${org} with ${perPageEntries} entries per page`);
+    github_src_logger.info(`Getting repository list for ${org} with ${perPageEntries} entries per page`);
     const octokit = await getOctokitForOrg(org);
     const options = octokit.repos.listForOrg.endpoint.merge({
         org: org,
@@ -297385,7 +297501,7 @@ async function getRepositoryList(org, perPageEntries = defaultPerPage) {
     return await doPaginatedRequest(options);
 }
 async function getTeamList(org, perPageEntries = defaultPerPage) {
-    organization_messageLog(`Getting team list for ${org} with ${perPageEntries} entries per page`);
+    github_src_logger.info(`Getting team list for ${org} with ${perPageEntries} entries per page`);
     const octokit = await getOctokitForOrg(org);
     const options = octokit.rest.teams.list.endpoint.merge({
         org: org,
@@ -297394,7 +297510,7 @@ async function getTeamList(org, perPageEntries = defaultPerPage) {
     return await doPaginatedRequest(options);
 }
 async function getUserList(org, perPageEntries = defaultPerPage) {
-    organization_messageLog(`Getting user list for ${org} with ${perPageEntries} entries per page`);
+    github_src_logger.info(`Getting user list for ${org} with ${perPageEntries} entries per page`);
     const octokit = await getOctokitForOrg(org);
     const options = await octokit.rest.orgs.listMembers.endpoint.merge({
         org: org,
@@ -297403,7 +297519,7 @@ async function getUserList(org, perPageEntries = defaultPerPage) {
     return await doPaginatedRequest(options);
 }
 async function validateMember(username, org) {
-    organization_messageLog(`Validating ${username} is a member of ${org}`);
+    github_src_logger.debug(`Validating ${username} is a member of ${org}`);
     const octokit = await getOctokitForOrg(org);
     const result = await octokit.orgs.checkMembershipForUser({
         org: org,
@@ -297412,7 +297528,7 @@ async function validateMember(username, org) {
     return result;
 }
 async function getUserRoleInOrg(username, org) {
-    organization_messageLog(`Getting user ${username} role in ${org}`);
+    github_src_logger.info(`Getting user ${username} role in ${org}`);
     const octokit = await getOctokitForOrg(org);
     const membership = await octokit.orgs.getMembershipForUser({
         org: org,
@@ -297421,13 +297537,13 @@ async function getUserRoleInOrg(username, org) {
     return membership.data.role;
 }
 async function getOrgInfo(org) {
-    organization_messageLog(`Getting info for org ${org}`);
+    github_src_logger.info(`Getting info for org ${org}`);
     const octokit = await getOctokitForOrg(org);
     const orgInfo = await octokit.orgs.get({ org });
     return orgInfo.data;
 }
 async function getOrgPlanName(org) {
-    organization_messageLog(`Getting plan for org ${org}`);
+    github_src_logger.info(`Getting plan for org ${org}`);
     const orgInfo = await getOrgInfo(org);
     return orgInfo.plan.name;
 }
@@ -297451,9 +297567,8 @@ async function doPaginatedRequest(options) {
 
 
 
-const repository_messageLog = src_default()('firestartr:github:repository');
 async function listReleases(repo, owner = 'prefapp') {
-    repository_messageLog(`Getting releases for ${owner}/${repo}`);
+    github_src_logger.info(`Getting releases for ${owner}/${repo}`);
     const octokit = await getOctokitForOrg(owner);
     const response = await octokit.rest.repos.listReleases({
         owner,
@@ -297464,7 +297579,7 @@ async function listReleases(repo, owner = 'prefapp') {
     return response.data;
 }
 async function getReleaseByTag(releaseTag, repo, owner = 'prefapp') {
-    repository_messageLog(`Getting release ${releaseTag} for ${owner}/${repo}`);
+    github_src_logger.info(`Getting release ${releaseTag} for ${owner}/${repo}`);
     const octokit = await getOctokitForOrg(owner);
     const response = await octokit.rest.repos.getReleaseByTag({
         owner,
@@ -297479,7 +297594,7 @@ async function getFileFromGithub(path, repo, owner = 'prefapp') {
     return await octokit.rest.repos.getContent({ owner, repo, path });
 }
 async function getContent(path, repo, owner = 'prefapp', ref = '') {
-    repository_messageLog(`Getting content for ${owner}/${repo}/${path}`);
+    github_src_logger.info(`Getting content for ${owner}/${repo}/${path}`);
     const octokit = await getOctokitForOrg(owner);
     const opts = {
         owner,
@@ -297493,19 +297608,19 @@ async function getContent(path, repo, owner = 'prefapp', ref = '') {
     return Buffer.from(content.data.content, 'base64').toString('utf8');
 }
 async function getRepoInfo(owner, name) {
-    repository_messageLog(`Getting repo info for ${owner}/${name}`);
+    github_src_logger.info(`Getting repo info for ${owner}/${name}`);
     const octokit = await getOctokitForOrg(owner);
     const res = await octokit.repos.get({ owner: owner, repo: name });
     return res['data'];
 }
 async function getPages(owner, name) {
-    repository_messageLog(`Getting pages for ${owner}/${name}`);
+    github_src_logger.info(`Getting pages for ${owner}/${name}`);
     const octokit = await getOctokitForOrg(owner);
     const res = await octokit.repos.getPages({ owner: owner, repo: name });
     return res['data'];
 }
 async function getOIDCRepo(owner, name) {
-    repository_messageLog(`Getting repo info for ${owner}/${name}`);
+    github_src_logger.info(`Getting repo info for ${owner}/${name}`);
     const octokit = await getOctokitForOrg(owner);
     return await octokit.request(`GET /repos/${owner}/${name}/actions/oidc/customization/sub`, {
         owner: owner,
@@ -297516,7 +297631,7 @@ async function getOIDCRepo(owner, name) {
     });
 }
 async function getBranchProtection(owner, repo, branch = 'main') {
-    repository_messageLog(`Getting branch protection for ${owner}/${repo}/${branch}`);
+    github_src_logger.info(`Getting branch protection for ${owner}/${repo}/${branch}`);
     const octokit = await getOctokitForOrg(owner);
     const res = await octokit.repos.getBranchProtection({
         owner: owner,
@@ -297526,13 +297641,13 @@ async function getBranchProtection(owner, repo, branch = 'main') {
     return res['data'];
 }
 async function getTeams(owner, repo) {
-    repository_messageLog(`Getting teams for ${owner}/${repo}`);
+    github_src_logger.info(`Getting teams for ${owner}/${repo}`);
     const octokit = await getOctokitForOrg(owner);
     const res = await octokit.repos.listTeams({ owner: owner, repo: repo });
     return res['data'];
 }
 async function getCollaborators(owner, repo, affiliation = 'direct') {
-    repository_messageLog(`Getting collaborators for ${owner}/${repo}`);
+    github_src_logger.info(`Getting collaborators for ${owner}/${repo}`);
     const octokit = await getOctokitForOrg(owner);
     const res = await octokit.repos.listCollaborators({
         owner: owner,
@@ -297543,7 +297658,7 @@ async function getCollaborators(owner, repo, affiliation = 'direct') {
 }
 async function setContent(path, fileContent, repo, owner = 'prefapp', branch = 'main', message = '') {
     const base64Content = Buffer.from(fileContent, 'utf8').toString('base64');
-    repository_messageLog(`Setting content for ${owner}/${repo}/${path}`);
+    github_src_logger.info(`Setting content for ${owner}/${repo}/${path}`);
     if (message === '') {
         message = `Update ${path}`;
     }
@@ -297551,10 +297666,10 @@ async function setContent(path, fileContent, repo, owner = 'prefapp', branch = '
     try {
         const currentContent = await getFileFromGithub(path, repo, owner);
         sha = currentContent.data.sha;
-        repository_messageLog('File already exists, updating it');
+        github_src_logger.debug('File already exists, updating it');
     }
     catch {
-        repository_messageLog('File does not exists, creating it');
+        github_src_logger.debug('File does not exist, creating it');
     }
     const octokit = await getOctokitForOrg(owner);
     await octokit.rest.repos.createOrUpdateFileContents({
@@ -297569,7 +297684,7 @@ async function setContent(path, fileContent, repo, owner = 'prefapp', branch = '
 }
 async function uploadFile(destinationPath, filePath, repo, owner = 'prefapp', branch = 'main', message = '') {
     if (!external_fs_.existsSync(filePath)) {
-        repository_messageLog(`File ${filePath} does not exists or is not readable`);
+        github_src_logger.error(`File ${filePath} does not exists or is not readable`);
         throw `${filePath} does not exists or is not readable`;
     }
     // Read file contents and call setContent
@@ -297578,16 +297693,16 @@ async function uploadFile(destinationPath, filePath, repo, owner = 'prefapp', br
 }
 async function deleteFile(path, repo, owner = 'prefapp', branch = 'main', message = '') {
     let sha = undefined;
-    repository_messageLog(`Deleting file ${owner}/${repo}/${path}`);
+    github_src_logger.info(`Deleting file ${owner}/${repo}/${path}`);
     try {
         const currentContent = await getFileFromGithub(path, repo, owner);
         sha = currentContent.data.sha;
     }
     catch {
-        repository_messageLog(`File ${path} does not exist in ${repo}`);
+        github_src_logger.error(`File ${path} does not exist in ${repo}`);
     }
     if (!sha) {
-        repository_messageLog(`File ${path} does not exist in ${repo}`);
+        github_src_logger.error(`File ${path} does not exist in ${repo}`);
         throw `File ${path} does not exist in ${repo}`;
     }
     if (message === '') {
@@ -297604,7 +297719,7 @@ async function deleteFile(path, repo, owner = 'prefapp', branch = 'main', messag
     });
 }
 async function addStatusCheck(output, is_failure, head_sha, name, status, repo, owner = 'prefapp') {
-    repository_messageLog(`Adding status checks to commit ${head_sha} in ${owner}/${repo}`);
+    github_src_logger.info(`Adding status checks to commit ${head_sha} in ${owner}/${repo}`);
     const octokit = await getOctokitForOrg(owner);
     const payload = { output, head_sha, name, owner, repo, status };
     if (status === 'completed') {
@@ -297613,7 +297728,7 @@ async function addStatusCheck(output, is_failure, head_sha, name, status, repo,
     await octokit.rest.checks.create(payload);
 }
 async function addCommitStatus(state, sha, repo, owner = 'prefapp', target_url = '', description = '', context = '') {
-    repository_messageLog(`Adding commit status with state ${state} to SHA ${sha} in ${owner}/${repo}`);
+    github_src_logger.info(`Adding commit status with state ${state} to SHA ${sha} in ${owner}/${repo}`);
     const octokit = await getOctokitForOrg(owner);
     await octokit.rest.repos.createCommitStatus({
         owner,
@@ -297645,9 +297760,8 @@ async function addCommitStatus(state, sha, repo, owner = 'prefapp', target_url =
 ;// CONCATENATED MODULE: ../github/src/team.ts
 
 
-const team_messageLog = src_default()('firestartr:github:team');
 async function getTeamMembers(team, org) {
-    team_messageLog(`Getting members for ${org}/${team}`);
+    github_src_logger.info(`Getting members for ${org}/${team}`);
     const octokit = await getOctokitForOrg(org);
     const res = await octokit.rest.teams.listMembersInOrg({
         org: org,
@@ -297656,13 +297770,13 @@ async function getTeamMembers(team, org) {
     return res['data'];
 }
 async function getTeamInfo(team, org) {
-    team_messageLog(`Getting info for ${org}/${team}`);
+    github_src_logger.info(`Getting info for ${org}/${team}`);
     const octokit = await getOctokitForOrg(org);
     const res = await octokit.rest.teams.getByName({ org: org, team_slug: team });
     return res['data'];
 }
 async function getTeamRoleUser(org, team, username) {
-    team_messageLog(`Getting role for ${username} in ${org}/${team}`);
+    github_src_logger.info(`Getting role for ${username} in ${org}/${team}`);
     const octokit = await getOctokitForOrg(org);
     const res = await octokit.rest.teams.getMembershipForUserInOrg({
         org: org,
@@ -297672,7 +297786,7 @@ async function getTeamRoleUser(org, team, username) {
     return res['data'];
 }
 async function create(org, team, privacy = 'closed') {
-    team_messageLog(`Creating team ${org}/${team}`);
+    github_src_logger.info(`Creating team ${org}/${team}`);
     const octokit = await getOctokitForOrg(org);
     return await octokit.rest.teams.create({
         org: org,
@@ -297681,7 +297795,7 @@ async function create(org, team, privacy = 'closed') {
     });
 }
 async function addOrUpdateMember(org, team, username, role = 'member') {
-    team_messageLog(`Adding or updating ${username} in ${org}/${team} with role ${role}`);
+    github_src_logger.info(`Adding or updating ${username} in ${org}/${team} with role ${role}`);
     const octokit = await getOctokitForOrg(org);
     return await octokit.rest.teams.addOrUpdateMembershipForUserInOrg({
         org: org,
@@ -297691,7 +297805,7 @@ async function addOrUpdateMember(org, team, username, role = 'member') {
     });
 }
 async function removeMember(org, team, username) {
-    team_messageLog(`Removing ${username} from ${org}/${team}`);
+    github_src_logger.info(`Removing ${username} from ${org}/${team}`);
     const octokit = await getOctokitForOrg(org);
     return await octokit.teams.removeMembershipForUserInOrg({
         org: org,
@@ -297711,9 +297825,8 @@ async function removeMember(org, team, username) {
 ;// CONCATENATED MODULE: ../github/src/user.ts
 
 
-const user_messageLog = src_default()('firestartr:github:user');
 async function getUserInfo(name) {
-    user_messageLog(`Getting user ${name} info`);
+    github_src_logger.info(`Getting user ${name} info`);
     const octokit = await getOctokitForOrg(name);
     return await octokit.users.getByUsername({ username: name });
 }
@@ -297724,11 +297837,10 @@ async function getUserInfo(name) {
 ;// CONCATENATED MODULE: ../github/src/pull_request.ts
 
 
-const pull_request_messageLog = src_default()('firestartr:github:pull_request');
 const commentMaxSize = 65535;
 async function commentInPR(comment, pr_number, repo, owner = 'prefapp') {
     try {
-        pull_request_messageLog(`Commenting ${comment} in PR ${pr_number} of ${owner}/${repo}`);
+        github_src_logger.info(`Commenting ${comment} in PR ${pr_number} of ${owner}/${repo}`);
         const octokit = await getOctokitForOrg(owner);
         await octokit.rest.issues.createComment({
             owner,
@@ -297747,12 +297859,12 @@ async function getPrData(pull_number, repo, owner) {
     return await octokit.rest.pulls.get({ owner, repo, pull_number });
 }
 async function getPrLastCommitSHA(pull_number, repo, owner = 'prefapp') {
-    pull_request_messageLog(`Getting last commit SHA for PR ${pull_number} of ${owner}/${repo}`);
+    github_src_logger.info(`Getting last commit SHA for PR ${pull_number} of ${owner}/${repo}`);
     const prData = await getPrData(pull_number, repo, owner);
     return prData.data.head.sha;
 }
 async function getPrMergeCommitSHA(pull_number, repo, owner = 'prefapp') {
-    pull_request_messageLog(`Getting merge commit SHA for PR ${pull_number} of ${owner}/${repo}`);
+    github_src_logger.info(`Getting merge commit SHA for PR ${pull_number} of ${owner}/${repo}`);
     const prData = await getPrData(pull_number, repo, owner);
     if (prData.data.merge_commit_sha !== null) {
         return prData.data.merge_commit_sha;
@@ -297790,7 +297902,7 @@ function divideCommentIntoChunks(comment, sizeReduction = 0) {
     return result;
 }
 async function getPrFiles(pr_number, repo, owner = 'prefapp') {
-    pull_request_messageLog(`Getting PR details of PR ${pr_number} of ${owner}/${repo}`);
+    github_src_logger.info(`Getting PR details of PR ${pr_number} of ${owner}/${repo}`);
     const octokit = await getOctokitForOrg(owner);
     return await octokit.rest.pulls.listFiles({
         owner,
@@ -297832,9 +297944,8 @@ async function filterPrBy(filter, opts) {
 ;// CONCATENATED MODULE: ../github/src/issues.ts
 
 
-const issues_log = src_default()('firestartr:github:issues');
 async function issues_create(owner, repo, title, body, labels = []) {
-    issues_log(`Creating issue in ${owner}/${repo}`);
+    github_src_logger.info(`Creating issue in ${owner}/${repo}`);
     const octokit = await getOctokitForOrg(owner);
     return await octokit.rest.issues.create({
         owner,
@@ -297845,7 +297956,7 @@ async function issues_create(owner, repo, title, body, labels = []) {
     });
 }
 async function update(owner, repo, issue_number, title, body, labels = []) {
-    issues_log(`Updating issue ${issue_number} in ${owner}/${repo}`);
+    github_src_logger.info(`Updating issue ${issue_number} in ${owner}/${repo}`);
     const octokit = await getOctokitForOrg(owner);
     return await octokit.rest.issues.update({
         owner,
@@ -297857,7 +297968,7 @@ async function update(owner, repo, issue_number, title, body, labels = []) {
     });
 }
 async function filterBy(owner, repo, title, labels, state = 'open', creator = undefined, assignee = undefined) {
-    issues_log(`Filtering issues by title in ${owner}/${repo}`);
+    github_src_logger.info(`Filtering issues by title in ${owner}/${repo}`);
     const octokit = await getOctokitForOrg(owner);
     const resp = await octokit.rest.issues.listForRepo({
         owner,
@@ -297872,7 +297983,7 @@ async function filterBy(owner, repo, title, labels, state = 'open', creator = un
     return resp.data.filter((issue) => issue.title.includes(title));
 }
 async function upsertByTitle(owner, repo, title, body, labels = []) {
-    issues_log(`Upserting issue by title in ${owner}/${repo}`);
+    github_src_logger.info(`Upserting issue by title in ${owner}/${repo}`);
     const foundIssues = await filterBy(owner, repo, title, labels.join(','));
     if (foundIssues.length > 0) {
         return update(owner, repo, foundIssues[0].number, title, body, labels);
@@ -297882,7 +297993,7 @@ async function upsertByTitle(owner, repo, title, body, labels = []) {
     }
 }
 async function issues_close(owner, repo, issue_number) {
-    issues_log(`Closing issue ${issue_number} in ${owner}/${repo}`);
+    github_src_logger.info(`Closing issue ${issue_number} in ${owner}/${repo}`);
     const octokit = await getOctokitForOrg(owner);
     return await octokit.rest.issues.update({
         owner,
@@ -297902,10 +298013,9 @@ async function issues_close(owner, repo, issue_number) {
 ;// CONCATENATED MODULE: ../github/src/branches.ts
 
 
-const branches_messageLog = src_default()('firestartr:github:branches');
 const SHA1_EMPTY_TREE = '4b825dc642cb6eb9a060e54bf8d69288fbee4904';
 async function listBranches(repo, owner = 'prefapp') {
-    branches_messageLog(`Getting branches for ${owner}/${repo}`);
+    github_src_logger.info(`Getting branches for ${owner}/${repo}`);
     const octokit = await getOctokitForOrg(owner);
     const response = await octokit.rest.repos.listBranches({
         owner,
@@ -297916,7 +298026,7 @@ async function listBranches(repo, owner = 'prefapp') {
     return response.data;
 }
 async function getBranch(repo, branch, owner = 'prefapp') {
-    branches_messageLog(`Getting branch ${branch} for ${owner}/${repo}`);
+    github_src_logger.info(`Getting branch ${branch} for ${owner}/${repo}`);
     const octokit = await getOctokitForOrg(owner);
     const response = await octokit.rest.repos.getBranch({
         owner,
@@ -297926,7 +298036,7 @@ async function getBranch(repo, branch, owner = 'prefapp') {
     return response.data;
 }
 async function createBranch(repo, branch, sha, owner = 'prefapp') {
-    branches_messageLog(`Creating branch ${branch} for ${owner}/${repo}`);
+    github_src_logger.info(`Creating branch ${branch} for ${owner}/${repo}`);
     const octokit = await getOctokitForOrg(owner);
     const response = await octokit.rest.git.createRef({
         owner,
@@ -297937,7 +298047,7 @@ async function createBranch(repo, branch, sha, owner = 'prefapp') {
     return response.data;
 }
 async function createOrphanBranch(repo, branch, owner = 'prefapp') {
-    branches_messageLog(`Creating orphan branch ${branch} for ${owner}/${repo}`);
+    github_src_logger.info(`Creating orphan branch ${branch} for ${owner}/${repo}`);
     const octokit = await getOctokitForOrg(owner);
     // Create a commit with an empty tree
     const { data: commit } = await octokit.request('POST /repos/{owner}/{repo}/git/commits', {
@@ -297963,6 +298073,268 @@ async function createOrphanBranch(repo, branch, owner = 'prefapp') {
     createOrphanBranch,
 });
 
+;// CONCATENATED MODULE: ../github/src/check_run.ts
+
+
+const FLUSH_TIMEOUT = 4; // seconds
+const GITHUB_OUTPUT_TEXT_LIMIT = 65000; // ~65k hard limit for output.text
+/**
+ * Streams text updates to a callback on a fixed cadence, with a size-triggered early flush.
+ * Does NOT clear content on flush (so the consumer can send the full, current log each time).
+ */
+class CheckRunBuffer {
+    constructor(initial = '', onFlush, opts) {
+        this.content = initial;
+        this.updated = Boolean(initial);
+        this.onFlush = onFlush;
+        this.flushIntervalMs = (opts?.intervalSec ?? FLUSH_TIMEOUT) * 1000;
+        this.timer = setInterval(() => {
+            this.flush();
+        }, this.flushIntervalMs);
+        if (initial)
+            this.flush();
+    }
+    stop() {
+        if (this.timer !== null) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    update(data = '') {
+        if (!data)
+            return;
+        this.content += data;
+        this.updated = true;
+    }
+    flush() {
+        if (!this.updated)
+            return;
+        try {
+            this.onFlush(this.content);
+        }
+        finally {
+            this.updated = false;
+        }
+    }
+    snapshot() {
+        return this.content;
+    }
+}
+class GithubCheckRun {
+    constructor(octokit, params) {
+        this.hasCommented = false;
+        this.closing = false;
+        this.closed = false;
+        this.lastStatus = 'in_progress';
+        this.detailsFormatter = (s) => s;
+        this.octokit = octokit;
+        this.owner = params.owner;
+        this.repo = params.repo;
+        this.headSHA = params.headSHA;
+        this.name = params.name;
+        this.detailsUrl = params.detailsUrl;
+        this.title = params.title ?? params.name;
+        if (params.summary)
+            this._summaryOverride = params.summary;
+        this.pullNumber = params.pullNumber;
+        this.includeCheckRunComment = Boolean(params.includeCheckRunComment);
+        this.checkRunComment = params.checkRunComment;
+        this.buffer = new CheckRunBuffer('', (data) => this.__updateCheckRun(data).catch(() => { }), { intervalSec: FLUSH_TIMEOUT });
+    }
+    /**
+     * Configure markdown formatting for the details (output.text).
+     * Example: ch.mdOptionsDetails({ quotes: 'terraform' })
+     * Result:
+     * ```terraform
+     * <log>
+     * ```
+     */
+    mdOptionsDetails(opts) {
+        const lang = (opts?.quotes ?? '').trim();
+        if (!lang) {
+            this.detailsFormatter = (s) => s;
+            return;
+        }
+        const fenceOpen = '```' + lang + '\n';
+        const fenceClose = '\n```';
+        const overhead = fenceOpen.length + fenceClose.length;
+        this.detailsFormatter = (body) => {
+            const maxBody = Math.max(0, GITHUB_OUTPUT_TEXT_LIMIT - overhead);
+            const safeBody = body.length > maxBody ? truncateRight(body, maxBody) : body;
+            return fenceOpen + safeBody + fenceClose;
+        };
+    }
+    set summary(data) {
+        this._summaryOverride = data;
+        // Push an immediate update if already created and not closed.
+        if (!this.closed && this.checkRunId) {
+            // do not mutate buffer flags; just send current snapshot using new summary
+            this.__updateCheckRun(this.buffer.snapshot()).catch(() => { });
+        }
+    }
+    get summary() {
+        return this._summaryOverride;
+    }
+    /**
+     * Append log text and optionally set status ('queued' | 'in_progress').
+     */
+    update(text, status) {
+        if (this.closed)
+            return;
+        if (status)
+            this.lastStatus = status;
+        if (text)
+            this.buffer.update(text);
+    }
+    /**
+     * Finalize the check with a conclusion. Flushes buffered text, marks completed.
+     */
+    async close(finalText, ok) {
+        if (this.closed || this.closing)
+            return;
+        this.closing = true;
+        this.buffer.stop();
+        const finalContent = this.buffer.snapshot() + (finalText || '');
+        try {
+            await this.__ensureCreated();
+            const { text, summary } = this.buildOutputTextAndSummary(finalContent);
+            await this.octokit.rest.checks.update({
+                owner: this.owner,
+                repo: this.repo,
+                check_run_id: this.checkRunId,
+                conclusion: ok ? 'success' : 'failure',
+                completed_at: new Date().toISOString(),
+                output: {
+                    title: this.title,
+                    summary,
+                    text,
+                },
+            });
+            this.closed = true;
+        }
+        finally {
+            this.closing = false;
+        }
+    }
+    // -------------------- Internals --------------------
+    async __ensureCreated() {
+        if (this.checkRunId)
+            return;
+        const startedAt = new Date().toISOString();
+        const res = await this.octokit.rest.checks.create({
+            owner: this.owner,
+            repo: this.repo,
+            name: this.name,
+            head_sha: this.headSHA,
+            status: 'in_progress',
+            started_at: startedAt,
+            details_url: this.detailsUrl,
+            output: {
+                title: this.title,
+                summary: this._summaryOverride ?? '',
+                text: undefined,
+            },
+        });
+        this.checkRunId = res.data.id;
+        if (this.includeCheckRunComment &&
+            this.pullNumber !== undefined &&
+            !this.hasCommented) {
+            const link = this.__buildCheckRunUrl();
+            const formattedLink = `[here](${link})`;
+            const base = this.checkRunComment ?? '';
+            const body = base ? `${base}${formattedLink}` : formattedLink;
+            await this.octokit.rest.issues.createComment({
+                owner: this.owner,
+                repo: this.repo,
+                issue_number: this.pullNumber,
+                body,
+            });
+            this.hasCommented = true;
+        }
+    }
+    async __updateCheckRun(allContent) {
+        if (this.closed || this.closing)
+            return;
+        await this.__ensureCreated();
+        const { text, summary } = this.buildOutputTextAndSummary(allContent);
+        await this.octokit.rest.checks.update({
+            owner: this.owner,
+            repo: this.repo,
+            check_run_id: this.checkRunId,
+            status: this.lastStatus,
+            output: {
+                title: this.title,
+                summary,
+                text,
+            },
+        });
+    }
+    __buildCheckRunUrl() {
+        if (this.checkRunId) {
+            return `https://github.com/${this.owner}/${this.repo}/runs/${this.checkRunId}?check_suite_focus=true`;
+        }
+        return `https://github.com/${this.owner}/${this.repo}/commit/${this.headSHA}/checks?check_suite_focus=true`;
+    }
+    buildOutputTextAndSummary(full) {
+        if (!full) {
+            return {
+                text: undefined,
+                summary: this._summaryOverride ?? '',
+            };
+        }
+        let text = this.detailsFormatter(full);
+        let truncated = false;
+        if (text.length > GITHUB_OUTPUT_TEXT_LIMIT) {
+            text = truncateRight(text, GITHUB_OUTPUT_TEXT_LIMIT);
+            truncated = true;
+        }
+        else {
+            truncated = text.length < full.length;
+        }
+        let summary = this._summaryOverride ?? '';
+        if (this._summaryOverride && truncated) {
+            summary = `${summary}\n\n... (log truncated to ~${GITHUB_OUTPUT_TEXT_LIMIT.toLocaleString()} chars)`;
+        }
+        return { text, summary };
+    }
+}
+// -------------------- Helpers --------------------
+function truncateRight(s, max) {
+    if (s.length <= max)
+        return s;
+    const HARD = Math.max(0, max - 3);
+    return s.slice(0, HARD) + '...';
+}
+/**
+ * Factory: build a GithubCheckRun using an installation token for the given org.
+ */
+async function createCheckRunForOrg(org, owner, repo, name, opts) {
+    const octokit = await getOctokitForOrg(org);
+    let headSHA = opts?.headSHA;
+    if (!headSHA && typeof opts?.pullNumber === 'number') {
+        headSHA = await getPrMergeCommitSHA(opts.pullNumber, repo, owner);
+    }
+    if (!headSHA) {
+        throw new Error('createCheckRunForOrg: either opts.headSHA or opts.pullNumber must be provided');
+    }
+    return new GithubCheckRun(octokit, {
+        owner,
+        repo,
+        headSHA,
+        name,
+        detailsUrl: opts?.detailsUrl,
+        title: opts?.title,
+        summary: opts?.summary,
+        pullNumber: opts?.pullNumber,
+        includeCheckRunComment: Boolean(opts?.includeCheckRunComment),
+        checkRunComment: opts?.checkRunComment,
+    });
+}
+async function createCheckRun(owner, repo, name, opts) {
+    return createCheckRunForOrg(owner, owner, repo, name, opts);
+}
+const CheckRun = GithubCheckRun;
+
 ;// CONCATENATED MODULE: ../github/index.ts
 
 
@@ -297973,6 +298345,7 @@ async function createOrphanBranch(repo, branch, owner = 'prefapp') {
 
 
 
+
 /* harmony default export */ const github_0 = ({
     org: organization,
     repo: repository,
@@ -297986,6 +298359,10 @@ async function createOrphanBranch(repo, branch, owner = 'prefapp') {
     pulls: pull_request,
     issues: issues,
     branches: branches,
+    feedback: {
+        createCheckRun: createCheckRun,
+        CheckRun: CheckRun,
+    },
 });
 
 ;// CONCATENATED MODULE: ../cdk8s_renderer/src/patches/base.ts
@@ -300247,11 +300624,17 @@ class TFWorkspaceNormalizer extends Normalizer {
 }
 async function normalizeModuleContent(tfRootModulePath) {
     let content = '';
+    const files = {};
     await crawl(tfRootModulePath, (entry) => {
         return entry.endsWith('.tf');
     }, (entry, data) => {
+        files[entry] = data;
+    });
+    Object.keys(files)
+        .sort()
+        .forEach((entry) => {
         content += `# ${external_path_.basename(entry)}
-${data}
+${files[entry]}
 `;
     });
     return content;
@@ -301500,14 +301883,14 @@ async function loadSchema(schemaURI) {
 
 
 const ajv = new (_2020_default())({ useDefaults: true });
-let initiated = false;
+let validation_initiated = false;
 const validations = {};
 function prepareValidation(schemaId) {
-    if (!initiated)
+    if (!validation_initiated)
         ajv.addSchema(base_schemas.schemas);
     if (!validations[schemaId])
         validations[schemaId] = ajv.getSchema(schemaId);
-    initiated = true;
+    validation_initiated = true;
     return validations[schemaId];
 }
 function validateClaim(data, schemaId = 'firestartr.dev://common/ClaimEnvelope') {
@@ -302081,6 +302464,19 @@ function isTerraformWorkspace(cr) {
     return cr.kind === 'FirestartrTerraformWorkspace';
 }
 
+;// CONCATENATED MODULE: ../cdk8s_renderer/src/validations/crSize.ts
+
+const K8S_OBJECT_SIZE_LIMIT = 1572864; // 1.5 MiB in bytes
+function validateCrSizes(crs) {
+    for (const [key, cr] of Object.entries(crs)) {
+        const serialized = catalog_common.io.toYaml(cr);
+        const size = Buffer.byteLength(serialized, 'utf8');
+        if (size > K8S_OBJECT_SIZE_LIMIT) {
+            throw new Error(`CR "${key}" exceeds the Kubernetes object size limit by ${size - K8S_OBJECT_SIZE_LIMIT} bytes`);
+        }
+    }
+}
+
 ;// CONCATENATED MODULE: ../cdk8s_renderer/src/refsSorter/refsSorter.ts
 
 /**
@@ -303141,7 +303537,7 @@ function addTraceabilityStamp(context, content) {
 
 
 
-const render_messageLog = src_default()('firestartr:features_renderer');
+const messageLog = src_default()('firestartr:features_renderer');
 function render(featurePath, featureRenderPath, entity, firestartrConfig = {}, featureArgs = {}) {
     const configData = validate_validate(featurePath);
     const context = buildContext(entity, configData.args, firestartrConfig, featureArgs);
@@ -303152,7 +303548,7 @@ function render(featurePath, featureRenderPath, entity, firestartrConfig = {}, f
         // For now let's keep upgradeable flag for backward compatibility
         // by default it's false
         const userManaged = file.user_managed ?? file.upgradeable ?? false;
-        render_messageLog(`Rendering ${src} to ${dest}`);
+        messageLog(`Rendering ${src} to ${dest}`);
         // render the content of the file
         const content = addTraceability(context, src, renderContent(external_fs_default().readFileSync(external_path_default().join(featurePath, 'templates', src)).toString(), context));
         const destFilePath = external_path_default().join(`${featureRenderPath}`, dest);
@@ -303205,6 +303601,209 @@ function renderContent(template, ctx) {
     return mustache_mustache.render(template, ctx, {}, ['{{|', '|}}']);
 }
 
+// EXTERNAL MODULE: external "node:fs"
+var external_node_fs_ = __nccwpck_require__(87561);
+// EXTERNAL MODULE: external "node:path"
+var external_node_path_ = __nccwpck_require__(49411);
+;// CONCATENATED MODULE: external "node:os"
+const external_node_os_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("node:os");
+;// CONCATENATED MODULE: ../features_renderer/src/auxiliar.ts
+// src/auxiliar.ts
+
+
+
+
+
+
+
+const renderTestsSchema = {
+    $schema: 'http://json-schema.org/draft-07/schema#',
+    type: 'object',
+    additionalProperties: false,
+    required: ['tests'],
+    properties: {
+        tests: {
+            type: 'array',
+            minItems: 1,
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                required: ['name', 'cr'],
+                properties: {
+                    name: { type: 'string', minLength: 1 },
+                    cr: { type: 'string', minLength: 1 },
+                    args: { type: 'object' },
+                },
+            },
+        },
+    },
+};
+const YAML_FILE_REGEX = /\.[yY]a?ml$/;
+/* ---------- Core helpers ---------- */
+function formatAjvErrors(errors) {
+    if (!errors || errors.length === 0)
+        return 'Unknown schema error';
+    return errors
+        .map((e) => {
+        const where = e.instancePath && e.instancePath.length ? e.instancePath : '/';
+        const msg = e.message ?? 'validation error';
+        return `- ${where} ${msg}`;
+    })
+        .join('\n');
+}
+function ensureUniqueTestNames(doc) {
+    const seen = new Set();
+    for (const t of doc.tests) {
+        if (seen.has(t.name)) {
+            throw new Error(`Duplicate test name "${t.name}" in render_tests.yaml`);
+        }
+        seen.add(t.name);
+    }
+}
+function loadAndValidateRenderTests(featurePath) {
+    const file = external_node_path_.join(featurePath, 'render_tests.yaml');
+    if (!external_node_fs_.existsSync(file)) {
+        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 validate = ajv.compile(renderTestsSchema);
+    const ok = validate(raw);
+    if (!ok) {
+        throw new Error(`render_tests.yaml schema validation failed:\n${formatAjvErrors(validate.errors ?? [])}`);
+    }
+    const doc = raw;
+    ensureUniqueTestNames(doc);
+    return doc;
+}
+function resolveCrPath(featurePath, crRelPath) {
+    if (external_node_path_.isAbsolute(crRelPath)) {
+        throw new Error(`CR path must be relative to the feature root, got absolute: ${crRelPath}`);
+    }
+    const resolved = external_node_path_.resolve(featurePath, crRelPath);
+    if (!external_node_fs_.existsSync(resolved)) {
+        throw new Error(`CR file not found (resolved from "${crRelPath}"): ${resolved}`);
+    }
+    return resolved;
+}
+function listYamlFiles(dir) {
+    if (!fs.existsSync(dir))
+        return [];
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        throw new Error(`Failed to read directory "${dir}": ${msg}`);
+    }
+    return entries
+        .filter((e) => e.isFile() && YAML_FILE_REGEX.test(e.name))
+        .map((e) => path.join(dir, e.name));
+}
+function loadYaml(file) {
+    try {
+        const configDataRaw = common_slurpFile(external_node_path_.join(file));
+        return catalog_common.io.fromYaml(configDataRaw);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        throw new Error(`Failed to parse YAML "${file}": ${msg}`);
+    }
+}
+function ensureSafeTmpNames(name) {
+    if (typeof name !== 'string' || !name.trim()) {
+        throw new Error('Test "name" must be a non-empty string');
+    }
+    if (name.length > 128) {
+        throw new Error('Test "name" is too long (max 128 characters)');
+    }
+    if (external_node_path_.isAbsolute(name)) {
+        throw new Error(`Test "name" must be relative, got absolute: "${name}"`);
+    }
+    if (name.includes('..')) {
+        throw new Error('Test "name" must not contain ".."');
+    }
+    if (!/^[A-Za-z0-9._-]+$/.test(name)) {
+        throw new Error('Test "name" may only contain letters, numbers, ".", "_", or "-"');
+    }
+}
+async function mkNamedTmp(...names) {
+    for (const name of names) {
+        ensureSafeTmpNames(name);
+    }
+    const dir = external_node_path_.join(external_node_os_namespaceObject.tmpdir(), ...names);
+    await promises_namespaceObject.rm(dir, { recursive: true, force: true });
+    await promises_namespaceObject.mkdir(dir, { recursive: true });
+    return dir;
+}
+async function mkTmp(prefix = 'feature-render-') {
+    return await fsp.mkdtemp(path.join(os.tmpdir(), prefix));
+}
+function buildExpectedOutput(config, renderDir) {
+    const files = (config.files || []).map((f) => ({
+        localPath: external_node_path_.join(renderDir, f.dest),
+        repoPath: f.dest,
+        userManaged: f.user_managed,
+    }));
+    return {
+        files,
+        patches: config.patches || [],
+    };
+}
+/* ---------- Context-style API for a render temp dir ---------- */
+async function createRenderContext(prefix = 'feature-render-') {
+    const dir = await mkTmp(prefix);
+    const join = (...p) => path.join(dir, ...p);
+    return {
+        getContextPath: () => dir,
+        join,
+        getFile: async (relPath, { yaml: asYaml = false, json: asJson = false, } = {}) => {
+            const data = await fsp.readFile(join(relPath), 'utf8');
+            if (asYaml)
+                return common.io.fromYaml(data);
+            if (asJson)
+                return JSON.parse(data);
+            return data;
+        },
+        getFilePath: (relPath) => join(relPath),
+        setFile: async (relPath, contents) => {
+            await fsp.mkdir(path.dirname(join(relPath)), { recursive: true });
+            await fsp.writeFile(join(relPath), contents);
+        },
+        exists: async (relPath) => {
+            try {
+                await fsp.access(join(relPath));
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        getOutputJson: async () => {
+            const p = join('output.json');
+            const raw = await fsp.readFile(p, 'utf8');
+            return JSON.parse(raw);
+        },
+        list: async (relPath = '.') => {
+            const entries = await fsp.readdir(join(relPath), {
+                withFileTypes: true,
+            });
+            return entries.map((e) => ({ name: e.name, isDir: e.isDirectory() }));
+        },
+        remove: async () => {
+            await fsp.rm(dir, { recursive: true, force: true });
+        },
+    };
+}
+/* harmony default export */ const auxiliar = ({
+    mkNamedTmp,
+    loadYaml,
+    buildExpectedOutput,
+    loadAndValidateRenderTests,
+    resolveCrPath,
+});
+
 ;// CONCATENATED MODULE: ../features_renderer/src/update_file.ts
 
 
@@ -303216,22 +303815,29 @@ function updateFileContent(featureRenderPath, filePath, content) {
 
 
 
+
 /* harmony default export */ const features_renderer = ({
     validate: validate_validate,
     render: render,
     updateFileContent: updateFileContent,
+    auxiliar: auxiliar,
+    buildContext: buildContext,
+    renderContent: renderContent,
 });
 
+;// CONCATENATED MODULE: ../features_preparer/src/logger.ts
+
+/* harmony default export */ const features_preparer_src_logger = (catalog_common.logger);
+
 ;// CONCATENATED MODULE: ../features_preparer/src/renderer.ts
 
 
 
 
-const renderer_messageLog = src_default()('firestartr:features_preparer:renderer');
 function renderFeature(featureName, version, owner, repo, featureOwner, renderPath = '/tmp', featureArgs = {}) {
     const extractPath = external_path_default().join(catalog_common.features.tarballs.getFeaturesExtractPath(featureName, version, owner, repo), 'packages', featureName);
     const renderedPath = catalog_common.features.features.getFeatureRenderedPathForEntity(featureOwner, featureName, renderPath);
-    renderer_messageLog(`Rendering feature ${featureName} to ${renderedPath} with component ${JSON.stringify(featureOwner)}`);
+    features_preparer_src_logger.info(`Rendering feature ${featureName} to ${renderedPath} with component ${JSON.stringify(featureOwner)}`);
     return features_renderer.render(extractPath, renderedPath, featureOwner, {}, featureArgs);
 }
 
@@ -303270,7 +303876,6 @@ async function downloadZipBall(url, filePath) {
 
 
 
-const installer_log = src_default()('firestartr:features_preparer:installer');
 async function getFeatureConfigFromRef(featureName, featureRef, featureOwner, // -> cr
 featureArgs = {}, repo = 'features', owner = 'prefapp') {
     // reference is the featureRef directly
@@ -303301,12 +303906,12 @@ async function prepareFeature(featureName, version, repo = 'features', owner = '
 async function downloadFeatureZip(repo, featureName, reference, owner = 'prefapp') {
     try {
         const zipballExtractPath = catalog_common.features.tarballs.getFeaturesExtractPath(featureName, reference, owner, repo, { createIfNotExists: false });
-        console.log(`Zipball extract path: ${zipballExtractPath}`);
+        features_preparer_src_logger.debug(`Zipball extract path: ${zipballExtractPath}`);
         if (external_fs_.existsSync(zipballExtractPath)) {
-            console.log(`Zipball extract path ${zipballExtractPath} already exists, reusing it.`);
+            features_preparer_src_logger.debug(`Zipball extract path ${zipballExtractPath} already exists, reusing it.`);
             return zipballExtractPath;
         }
-        installer_log(`Feature ${[featureName, reference, owner, repo].join('-')} has not been downloaded yet, downloading`);
+        features_preparer_src_logger.info(`Feature ${[featureName, reference, owner, repo].join('-')} has not been downloaded yet, downloading`);
         const octokit = await github_0.getOctokitForOrg(owner);
         const response = await octokit.request('GET /repos/{owner}/{repo}/zipball/{reference}', {
             request: {
@@ -303317,28 +303922,28 @@ async function downloadFeatureZip(repo, featureName, reference, owner = 'prefapp
             reference,
         });
         const randomZipTmpPath = `/tmp/${catalog_common.generic.randomString(20)}.zip`;
-        console.log(`Downloading feature ${featureName} version ${reference} to ${randomZipTmpPath}`);
+        features_preparer_src_logger.info(`Downloading feature ${featureName} version ${reference} to ${randomZipTmpPath}`);
         if (external_fs_.existsSync(randomZipTmpPath)) {
-            console.log(`Temporary zip file ${randomZipTmpPath} already exists, removing it.`);
+            features_preparer_src_logger.debug(`Temporary zip file ${randomZipTmpPath} already exists, removing it.`);
             external_fs_.unlinkSync(randomZipTmpPath);
         }
         const randomExtractPath = `/tmp/${catalog_common.generic.randomString(20)}`;
-        console.log(`Extracting feature ${featureName} version ${reference} to ${randomExtractPath}`);
+        features_preparer_src_logger.debug(`Extracting feature ${featureName} version ${reference} to ${randomExtractPath}`);
         external_fs_.rmSync(randomExtractPath, { recursive: true, force: true });
         await downloadZipBall(response.url, randomZipTmpPath);
         const zip = new (adm_zip_default())(randomZipTmpPath);
         const mainEntry = zip.getEntries()[0].entryName;
-        console.log(`Main entry in zip: ${mainEntry}`);
-        console.log(`Extracting zip to ${randomExtractPath}`);
+        features_preparer_src_logger.debug(`Main entry in zip: ${mainEntry}`);
+        features_preparer_src_logger.debug(`Extracting zip to ${randomExtractPath}`);
         zip.extractAllTo(randomExtractPath, true);
-        console.log(`Renaming main entry ${mainEntry} to ${zipballExtractPath}`);
+        features_preparer_src_logger.debug(`Renaming main entry ${mainEntry} to ${zipballExtractPath}`);
         external_fs_.renameSync(`${randomExtractPath}/${mainEntry}`, zipballExtractPath);
-        console.log(`Removing temporary zip file ${randomZipTmpPath}`);
+        features_preparer_src_logger.debug(`Removing temporary zip file ${randomZipTmpPath}`);
         external_fs_.unlinkSync(randomZipTmpPath);
         return zipballExtractPath;
     }
     catch (error) {
-        console.error(error);
+        features_preparer_src_logger.error(`Error on prepare feature with tag ${reference}: ${error}`);
         throw new Error(`Error for feature with tag ${reference}: ${error}. GitHub response: ${error}`);
     }
 }
@@ -307224,6 +307829,7 @@ async function renderClaim(catalogScope, firestartrScope, claim, patches, previo
 
 
 
+
 /*
  * Function called when rendering but not importing
  *
@@ -307239,6 +307845,7 @@ async function renderer_render(catalogScope, firestartrScope, activateReferentia
     const data = await loadClaimsList(claimList);
     const result = await renderClaims(catalogScope, firestartrScope, data);
     validateTfStateKeyUniqueness(result);
+    validateCrSizes(result);
     return result;
 }
 
@@ -308927,60 +309534,9 @@ const scaffoldSubcommand = {
 
 // EXTERNAL MODULE: ../../node_modules/@kubernetes/client-node/dist/index.js
 var client_node_dist = __nccwpck_require__(54851);
-// EXTERNAL MODULE: ../../node_modules/winston/lib/winston.js
-var winston = __nccwpck_require__(66752);
-var winston_default = /*#__PURE__*/__nccwpck_require__.n(winston);
 ;// CONCATENATED MODULE: ../operator/src/logger.ts
 
-const validLogLevels = [
-    'error',
-    'warn',
-    'info',
-    'debug',
-    'verbose',
-    'silly',
-];
-let logger_initiated = false;
-let logger = null;
-// Type guard to check if a value is a valid LogLevel
-function isValidLogLevel(level) {
-    return (typeof level === 'string' && validLogLevels.includes(level));
-}
-function initLogger() {
-    if (logger_initiated)
-        return;
-    const logLevel = process.env.LOG_LEVEL && isValidLogLevel(process.env.LOG_LEVEL)
-        ? process.env.LOG_LEVEL
-        : 'info';
-    logger = winston_default().createLogger({
-        level: logLevel,
-        exitOnError: false,
-        format: winston.format.combine(winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }), winston.format.json()),
-        transports: [
-            new winston.transports.Console({
-                level: logLevel,
-            }),
-        ],
-    });
-    logger_initiated = true;
-}
-function doLog(level, args) {
-    initLogger();
-    const [message, metadata] = args;
-    // eslint-disable-next-line prefer-spread
-    logger[level].apply(logger, [
-        message + ' | ' + JSON.stringify({ ...metadata }),
-    ]);
-}
-const logger_log = {
-    error: (...args) => doLog('error', args),
-    warn: (...args) => doLog('warn', args),
-    info: (...args) => doLog('info', args),
-    debug: (...args) => doLog('debug', args),
-    verbose: (...args) => doLog('verbose', args),
-    silly: (...args) => doLog('silly', args),
-};
-/* harmony default export */ const src_logger = (logger_log);
+/* harmony default export */ const operator_src_logger = (catalog_common.logger);
 
 ;// CONCATENATED MODULE: ../operator/src/store.ts
 
@@ -308991,13 +309547,7 @@ class Store {
         this.kind = kind;
     }
     add(item) {
-        src_logger.debug('STORE_ADD_ITEM', {
-            metadata: {
-                name: item.metadata.name,
-                kind: this.kind,
-                namespace: item.metadata.namespace,
-            },
-        });
+        operator_src_logger.debug(`Added item '${item.metadata.name}' of kind '${this.kind}' to the store in namespace '${item.metadata.namespace}'`);
         this.store[itemPath(this.kind, item)] = {
             item,
         };
@@ -309006,13 +309556,7 @@ class Store {
         return 'deletionTimestamp' in item.metadata;
     }
     markToDelete(item) {
-        src_logger.debug('STORE_MARKED_ITEM_TO_DELETE', {
-            metadata: {
-                name: item.metadata.name,
-                kind: this.kind,
-                namespace: item.metadata.namespace,
-            },
-        });
+        operator_src_logger.debug(`Marked item '${item.metadata.name}' of kind '${this.kind}' for deletion in namespace '${item.metadata.namespace}'`);
         this.store[itemPath(this.kind, item)] = {
             item,
             markedToDelete: true,
@@ -309045,24 +309589,11 @@ class Store {
             item,
         };
         if (updated)
-            src_logger.debug('STORE_ITEM_MODIFIED', {
-                metadata: {
-                    name: item.metadata.name,
-                    kind: this.kind,
-                    namespace: item.metadata.namespace,
-                    patches,
-                },
-            });
+            operator_src_logger.debug(`Modified item '${item.metadata.name}' of kind '${this.kind}' in namespace '${item.metadata.namespace}' with patches ${JSON.stringify(patches)}`);
         return updated;
     }
     remove(item) {
-        src_logger.debug('STORE_ITEM_REMOVED', {
-            metadata: {
-                name: item.metadata.name,
-                kind: this.kind,
-                namespace: item.metadata.namespace,
-            },
-        });
+        operator_src_logger.debug(`Removed item '${item.metadata.name}' of kind '${this.kind}' from namespace '${item.metadata.namespace}'`);
         delete this.store[itemPath(this.kind, item)];
     }
     getItem(item) {
@@ -309109,7 +309640,7 @@ async function getItem(kind, namespace, item) {
 }
 async function getItemByItemPath(itemPath, apiGroup = catalog_common.types.controller.FirestartrApiGroup, apiVersion = 'v1') {
     try {
-        src_logger.debug('CTL_GET_ITEM', { metadata: { itemPath } });
+        operator_src_logger.debug(`The ctl is getting the item at '${itemPath}'.`);
         const { kc, opts } = await ctl_getConnection();
         opts.headers['Content-Type'] = 'application/json';
         opts.headers['Accept'] = 'application/json';
@@ -309119,14 +309650,14 @@ async function getItemByItemPath(itemPath, apiGroup = catalog_common.types.contr
         const r = await fetch(url, { method: 'get', headers: opts.headers });
         if (!r.ok) {
             const err = new Error(`Error on getItemByItemPath: ${itemPath}: ${r.statusText}`);
-            console.log(err.stack);
+            operator_src_logger.error(`Error on getItemByItemPath: ${itemPath}: ${r.statusText}`);
             throw err;
         }
         const jsonResponse = await r.json();
         return jsonResponse;
     }
     catch (e) {
-        console.dir(e, { depth: null });
+        operator_src_logger.error(`Error on getItemByItemPath: ${e}`);
         throw e;
     }
 }
@@ -309146,17 +309677,15 @@ async function writeManifest(kind, namespace, item, apiSlug) {
     return jsonResponse;
 }
 function writeSecret(secret, namespace) {
-    log.debug('CTL_WRITE_SECRET', {
-        metadata: { namespace, name: secret.metadata.name },
-    });
+    log.debug(`The ctl is writing the secret '${secret.metadata.name}' in namespace '${namespace}'.`);
     return writeManifest('secrets', namespace, secret, `api/v1/namespaces/${namespace}/secrets/${secret.metadata.name}`);
 }
 async function writeStatus(kind, namespace, item) {
-    src_logger.debug('CTL_WRITE_STATUS', { metadata: { item } });
+    operator_src_logger.debug(`The ctl is writing the status for item '${item.kind}/${item.metadata.name}' in namespace '${item.metadata.namespace}'.`);
     return await writeManifest(kind, namespace, item, `apis/firestartr.dev/v1/namespaces/${namespace}/${kind}/${item.metadata.name}/status`);
 }
 function writeFinalizer(kind, namespace, item) {
-    log.debug('CTL_WRITE_FINALIZER', { metadata: { item } });
+    log.debug(`The ctl is writing the status for item '${item.kind}/${item.metadata.name}' in namespace '${item.metadata.namespace}'.`);
     return writeManifest(kind, namespace, item, `apis/firestartr.dev/v1/namespaces/${namespace}/${kind}/${item.metadata.name}/metadata/finalizers`);
 }
 async function listItems(kind, namespace, kc, opts) {
@@ -309171,7 +309700,7 @@ async function listItems(kind, namespace, kc, opts) {
         return await r.json();
     }
     catch (err) {
-        console.dir(err);
+        log.error(`On listItems: ${err}`);
         throw err;
     }
 }
@@ -309198,15 +309727,10 @@ async function* observeList(kind, namespace, revision, kc, opts) {
     }
     catch (err) {
         if (err instanceof TypeError) {
-            log.error('CTL_OBSERVE_LIST_ERROR_CHUNKS', {
-                metadata: { namespace, kind, revision, error: err },
-            });
+            log.error(`The ctl encountered an error while listing chunks for '${kind}' with revision '${revision}' in namespace '${namespace}': '${err}'.`);
         }
         else {
-            log.error('CTL_OBSERVE_LIST_UNKNOWN_ERROR_CHUNKS', {
-                metadata: { namespace, kind, revision, error: err },
-            });
-            console.error(err);
+            log.error(`The ctl encountered an unknown error while listing chunks for '${kind}' with revision '${revision}' in namespace '${namespace}': '${err}'.`);
         }
     }
 }
@@ -309229,7 +309753,7 @@ async function ctl_getConnection() {
         return { kc, opts };
     }
     catch (err) {
-        console.dir(err, { depth: null });
+        operator_src_logger.error(`getConnection: ${err}`);
         throw err;
     }
 }
@@ -309288,9 +309812,7 @@ async function deleteSecret(secretName, namespace) {
     }
     catch (e) {
         if (e && e.code === 404) {
-            src_logger.error('CTL_DELETE_SECRET_NOT_FOUND', {
-                metadata: { secretName, namespace },
-            });
+            operator_src_logger.error(`The ctl failed to delete the secret '${secretName}' in namespace '${namespace}' because it was not found.`);
             return null;
         }
         else {
@@ -309324,9 +309846,7 @@ async function getSecret(namespace, secretName) {
     }
     catch (e) {
         if (e.response && e.response.statusCode === 404) {
-            src_logger.error('CTL_SECRET_NOT_FOUND', {
-                metadata: { secretName, namespace },
-            });
+            operator_src_logger.error(`The ctl could not find the secret '${secretName}' in namespace '${namespace}'.`);
             return null;
         }
         else {
@@ -309357,13 +309877,7 @@ async function getTFResult(namespace, item) {
  * @param {any} item - Object to check if has been renamed
  */
 async function checkIfRenamed(namespace, item) {
-    log.debug('CTL_CHECK_IF_RENAMED', {
-        metadata: {
-            kind: item.kind,
-            name: item.metadata.name,
-            namespace,
-        },
-    });
+    log.debug(`The ctl is checking if item '${item.kind}/${item.metadata.name}' in namespace '${namespace}' has been renamed.`);
     const oldName = item.metadata?.labels?.[common.types.controller.FirestartrLabelOldName];
     // If the item does not have firestartr.dev/old-name label, it has not been renamed
     if (!oldName)
@@ -309379,9 +309893,7 @@ async function checkIfRenamed(namespace, item) {
         });
         if (!r.ok) {
             if (r.status === 404) {
-                log.debug('CTL_CHECK_IF_RENAMED_OLDNAME_NOT_FOUND', {
-                    metadata: { kind: item.kind, name: item.metadata.name, namespace },
-                });
+                log.debug(`The ctl is checking for a rename of item '${item.kind}/${item.metadata.name}' in namespace '${namespace}', but the old item name was not found.`);
                 return false;
             }
         }
@@ -309389,21 +309901,17 @@ async function checkIfRenamed(namespace, item) {
         return true;
     }
     catch (err) {
-        console.log(err);
+        log.debug(err);
         return false;
     }
 }
 async function upsertFinalizer(kind, namespace, item, finalizer) {
     if ('finalizers' in item.metadata &&
         item.metadata.finalizers.includes(finalizer)) {
-        src_logger.debug('CTL_UPSERT_FINALIZER_ALREADY_SET', {
-            metadata: { finalizer, kind, name: item.metadata.name, namespace },
-        });
+        operator_src_logger.debug(`The ctl tried to upsert the finalizer '${finalizer}' for '${kind}/${item.metadata.name}' in namespace '${namespace}', but it was already set.`);
         return;
     }
-    src_logger.debug('CTL_UPSERT_FINALIZER_SETTING', {
-        metadata: { finalizer, kind, name: item.metadata.name, namespace },
-    });
+    operator_src_logger.debug(`The ctl is setting the finalizer '${finalizer}' 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';
@@ -309444,14 +309952,7 @@ 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;
-    src_logger.debug('CTL_REMOVE_FINALIZER', {
-        metadata: {
-            finalizer,
-            kind,
-            name,
-            namespace,
-        },
-    });
+    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'] = '*';
@@ -309513,8 +310014,7 @@ async function writePlanInGithubPR(prUrl, planText) {
         await github_0.pulls.commentInPR(message, +pr_number, repo, owner);
     }
     catch (err) {
-        console.error(err);
-        console.log('Cannot write plan in PR');
+        operator_src_logger.error(`writePlanInGithubPR: Cannot write plan in PR: ${err}`);
     }
 }
 async function addApplyCommitStatus(cr, state, targetURL = '', description = '', context = '') {
@@ -309522,15 +310022,7 @@ async function addApplyCommitStatus(cr, state, targetURL = '', description = '',
         await addCommitStatusToPrMergeCommit(cr.metadata.annotations['firestartr.dev/last-state-pr'], state, targetURL, description, context);
     }
     catch (e) {
-        src_logger.error('CTL_ADD_APPLY_COMMIT_STATUS_ERROR', {
-            metadata: {
-                state,
-                targetURL,
-                description,
-                cr_metadata: cr.metadata,
-                error: e,
-            },
-        });
+        log.error(`The ctl encountered an error while adding commit status for custom resource '${cr.metadata.name}' in namespace '${cr.metadata.namespace}'. State: '${state}'. Target URL: '${targetURL}'. Description: '${description}'. Error: '${e}'.`);
     }
 }
 async function addDestroyCommitStatus(cr, state, description = '', context = '') {
@@ -309539,50 +310031,33 @@ async function addDestroyCommitStatus(cr, state, description = '', context = '')
         await addCommitStatusToPrMergeCommit(prUrl, state, '', description, context);
     }
     catch (e) {
-        src_logger.error('CTL_ADD_DESTROY_COMMIT_STATUS_ERROR', {
-            metadata: {
-                state,
-                description,
-                cr_metadata: cr.metadata,
-                error: e,
-            },
-        });
+        operator_src_logger.error(`The ctl encountered an error while adding the destroy commit status for custom resource '${cr.metadata.name}' in namespace '${cr.metadata.namespace}'. State: '${state}'. Description: '${description}'. Error: '${e}'.`);
     }
 }
 async function addPlanStatusCheck(prUrl, summary, status = 'in_progress', isFailure = false) {
     try {
-        src_logger.debug('CTL_ADD_PLAN_STATUS_CHECK_SUMMARY_LENGTH', {
-            metadata: { length: summary.length },
-        });
+        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) {
             const mustDrop = summary.length - MAX_CHARS_OUPUT_PLAN;
             summary = summary.substring(mustDrop);
-            src_logger.debug('CTL_ADD_PLAN_STATUS_CHECK_SUMMARY_TOO_LENGTHY', {
-                metadata: { mustDrop, length: summary.length },
-            });
+            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);
     }
     catch (e) {
-        src_logger.error('CTL_ADD_PLAN_STATUS_CHECK_ERROR', {
-            metadata: { prUrl, status, isFailure, error: 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}'.`);
     }
 }
 async function ctl_addStatusCheck(output, isFailure, name, prAnnotationValue, status) {
     const { owner, repo, prNumber } = catalog_common.generic.getOwnerRepoPrNumberFromAnnotationValue(prAnnotationValue);
     const branchSha = await github_0.pulls.getPrLastCommitSHA(prNumber, repo, owner);
-    src_logger.info('CTL_ADD_STATUS_CHECK', {
-        metadata: { owner, repo, branchSha, prAnnotationValue, name },
-    });
+    operator_src_logger.info(`The ctl is adding a status check for '${owner}/${repo}' on branch '${branchSha}' with PR annotation value '${prAnnotationValue}' and name '${name}'.`);
     await github_0.repo.addStatusCheck(output, isFailure, branchSha, name, status, repo, owner);
 }
 async function addCommitStatusToPrMergeCommit(prAnnotationValue, state, targetURL, description, context) {
     const { owner, repo, prNumber } = catalog_common.generic.getOwnerRepoPrNumberFromAnnotationValue(prAnnotationValue);
     const branchSha = await github_0.pulls.getPrMergeCommitSHA(prNumber, repo, owner);
-    src_logger.info('CTL_ADD_COMMIT_STATUS', {
-        metadata: { owner, repo, branchSha, state, targetURL },
-    });
+    operator_src_logger.info(`The ctl is adding a commit status for '${owner}/${repo}' on branch '${branchSha}'. State: '${state}'. Target URL: '${targetURL}'.`);
     await github_0.repo.addCommitStatus(state, branchSha, repo, owner, targetURL, description, context);
 }
 async function getLastStatePrInfo(cr) {
@@ -309650,62 +310125,42 @@ async function observe(plural, namespace, onAdd, onChange, onDelete, _onRename)
         informer.on('add', (obj) => {
             store.add(obj);
             if (store.hasDeletionTimestamp(obj)) {
-                src_logger.info('REFLECTOR_ITEM_MARKED_TO_DELETION', {
-                    metadata: { kind: obj.kind, name: obj.metadata.name },
-                });
+                operator_src_logger.info(`Reflector has marked item '${obj.kind}/${obj.metadata.name}' for deletion.`);
                 store.markToDelete(obj);
                 onDelete(obj);
             }
             else {
-                src_logger.info('REFLECTOR_ITEM_ADDED', {
-                    metadata: { kind: obj.kind, name: obj.metadata.name },
-                });
+                operator_src_logger.info(`Reflector has added item '${obj.kind}/${obj.metadata.name}'.`);
                 onAdd(obj);
             }
         });
         informer.on('update', (obj) => {
-            src_logger.info('REFLECTOR_ITEM_UPDATED', {
-                metadata: {
-                    kind: obj.kind,
-                    name: obj.metadata.name,
-                    resourceVersion: obj.metadata.resourceVersion,
-                },
-            });
+            operator_src_logger.info(`Reflector has updated item '${obj.kind}/${obj.metadata.name}' to a new resource version: '${obj.metadata.resourceVersion}'.`);
             if (!store.getItem(obj).markedToDelete &&
                 store.hasDeletionTimestamp(obj) &&
                 (store.hasBeenMarkedToDelete(obj) || store.modified(obj))) {
-                src_logger.info('REFLECTOR_ITEM_UPDATED_MARKED_TO_DELETION', {
-                    metadata: { kind: obj.kind, name: obj.metadata.name },
-                });
+                operator_src_logger.info(`Reflector has updated item '${obj.kind}/${obj.metadata.name}' and marked it for deletion.`);
                 store.markToDelete(obj);
                 onDelete(obj);
             }
             else if (store.modified(obj)) {
-                src_logger.info('REFLECTOR_ITEM_UPDATED_AND_MODIFIED', {
-                    metadata: { kind: obj.kind, name: obj.metadata.name },
-                });
+                operator_src_logger.info(`Reflector has updated and modified item '${obj.kind}/${obj.metadata.name}'.`);
                 onChange(obj);
             }
         });
         informer.on('delete', (obj) => {
             // deleted from the etcd
-            src_logger.info('REFLECTOR_ITEM_DELETED', {
-                metadata: { kind: obj.kind, name: obj.metadata.name },
-            });
+            operator_src_logger.info(`Reflector has deleted item '${obj.kind}/${obj.metadata.name}' from the etcd.`);
             store.remove(obj);
         });
         informer.on('error', (err) => {
-            src_logger.error('REFLECTOR_ITEM_ERROR', {
-                metadata: { error: err, plural, namespace },
-            });
+            operator_src_logger.error(`An error occurred in the reflector for '${plural}' in namespace '${namespace}': '${err}'.`);
             setTimeout(async () => {
                 try {
                     await informer.start();
                 }
                 catch (err) {
-                    src_logger.error('REFLECTOR_INFORMER_START_ERROR', {
-                        metadata: { error: err, plural, namespace },
-                    });
+                    operator_src_logger.error(`Failed to start the reflector informer for '${plural}' in namespace '${namespace}': '${err}'.`);
                 }
             }, 5000);
         });
@@ -309725,13 +310180,13 @@ async function needsProvisioningOnCreate(cr) {
     const fCrLog = (cr) => `The item ${cr.kind}: ${cr.metadata.name}`;
     // NO STATUS
     if (!('status' in cr) || !('conditions' in cr.status)) {
-        src_logger.debug('STATUS_NO_STATUS_NOR_CONDITION', { metadata: { cr } });
+        operator_src_logger.debug(`The custom resource '${cr.kind}/${cr.metadata.name}' is missing a status and any conditions.`);
         return true;
     }
     // ERROR
     const errCond = getConditionByType(cr.status.conditions, 'ERROR');
     if (errCond && errCond.status === 'True') {
-        src_logger.debug('STATUS_ERROR_SKIP_PROVISION', { metadata: { cr } });
+        operator_src_logger.debug(`Skipping the provisioning process for custom resource '${cr.kind}/${cr.metadata.name}' due to a status error.`);
         return false;
     }
     // PROVISIONED
@@ -309739,7 +310194,7 @@ async function needsProvisioningOnCreate(cr) {
     if (provCond &&
         provCond.status === 'True' &&
         provCond.observedGeneration >= cr.metadata.generation) {
-        src_logger.debug('STATUS_ALREADY_PROVISIONED', { metadata: { cr } });
+        operator_src_logger.debug(`The custom resource '${cr.kind}/${cr.metadata.name}' is already provisioned; skipping the process.`);
         return false;
     }
     // DELETED
@@ -309747,29 +310202,20 @@ async function needsProvisioningOnCreate(cr) {
     if (delCond &&
         delCond.status === 'True' &&
         delCond.observedGeneration >= cr.metadata.generation) {
-        src_logger.debug('STATUS_ALREADY_DELETED', { metadata: { cr } });
+        operator_src_logger.debug(`The custom resource '${cr.kind}/${cr.metadata.name}' has already been deleted; no action is required.`);
         return false;
     }
     // PROVISIONING
     const provisioningCondition = getConditionByType(cr.status.conditions, 'PROVISIONING');
     if (provisioningCondition && provisioningCondition.status === 'True') {
-        src_logger.debug('STATUS_IN_PROVISIONING_REPROVISIONING', { metadata: { cr } });
+        operator_src_logger.debug(`The custom resource '${cr.kind}/${cr.metadata.name}' is currently in a provisioning or reprovisioning state.`);
         return true;
     }
-    src_logger.debug('STATUS_NOT_HANDLED_STATE_SKIP_PROVISIONING', { metadata: { cr } });
+    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;
 }
 async function updateTransition(itemPath, reason, type, statusValue, message = '', updateStatusOnly = false) {
-    src_logger.info('STATUS_UPDATE_TRANSITION_FOR_ITEM', {
-        metadata: {
-            itemPath,
-            reason,
-            type,
-            statusValue,
-            message,
-            updateStatusOnly,
-        },
-    });
+    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}'.`);
     const k8sItem = await getItemByItemPath(itemPath);
     if (!('status' in k8sItem))
         k8sItem.status = {};
@@ -309852,7 +310298,7 @@ async function syncer(enqueue) {
     void loop(enqueue);
     return {
         addItem(itemPath) {
-            src_logger.info('SYNC_ADD_ITEM', { metadata: { itemPath } });
+            operator_src_logger.info(`Added item of path '${itemPath}' for synchronization`);
             void itemIsSyncable(itemPath).then((itemSyncInfo) => {
                 if (!itemSyncInfo.syncable) {
                     return;
@@ -309864,7 +310310,7 @@ async function syncer(enqueue) {
                     }, helperCalculateRevisionTime(itemSyncInfo.period)),
                     needsRevision: false,
                 };
-                src_logger.info('Configured syncing for item %s %s', itemPath, syncWatchers[itemPath]);
+                operator_src_logger.info(`Configured synchronization for item at path '${itemPath}'`);
             });
         },
         updateItem(itemPath) {
@@ -309872,13 +310318,13 @@ async function syncer(enqueue) {
             //  log('Item %s not found, ignoring...', itemPath)
             //  return
             //}
-            src_logger.debug('SYNC_UPDATE_ITEM', { metadata: { itemPath } });
+            operator_src_logger.debug(`Updated item of path '${itemPath}' during synchronization`);
             void itemIsSyncable(itemPath).then((itemSyncInfo) => {
                 if (!itemSyncInfo.syncable) {
                     if (syncWatchers[itemPath]) {
                         clearInterval(syncWatchers[itemPath].lastRevision);
                         delete syncWatchers[itemPath];
-                        src_logger.info('SYNC_REMOVE_FOR_ITEM', { metadata: { itemPath } });
+                        operator_src_logger.info(`Removed item of path '${itemPath}' from synchronization`);
                     }
                 }
                 else {
@@ -309892,26 +310338,19 @@ async function syncer(enqueue) {
                         }, helperCalculateRevisionTime(itemSyncInfo.period)),
                         needsRevision: false,
                     };
-                    src_logger.debug('SYNC_CONFIGURED_FOR_ITEM', {
-                        metadata: {
-                            itemPath,
-                            watcher: syncWatchers[itemPath],
-                        },
-                    });
+                    operator_src_logger.debug(`Configured synchronization for item at path '${itemPath}' with watcher '${syncWatchers[itemPath]}'`);
                 }
             });
         },
         deleteItem(itemPath) {
             if (!syncWatchers[itemPath]) {
-                src_logger.debug('SYNC_DELETE_ITEM_NOT_FOUND_IGNORE', {
-                    metadata: { itemPath },
-                });
+                operator_src_logger.debug(`Ignored deletion attempt for item at path '${itemPath}' as it was not found during synchronization`);
                 return;
             }
-            src_logger.debug('SYNC_DELETE_ITEM', { metadata: { itemPath } });
+            operator_src_logger.debug(`Deleted item of path '${itemPath}' during synchronization`);
             clearInterval(syncWatchers[itemPath].lastRevision);
             delete syncWatchers[itemPath];
-            src_logger.debug('SYNC_DELETE_ITEM_DELETED', { metadata: { itemPath } });
+            operator_src_logger.debug(`Successfully deleted item at path '${itemPath}' during synchronization`);
         },
     };
 }
@@ -309983,13 +310422,7 @@ async function initRetry(enqueue) {
 function retry(itemPath) {
     if (retryWatchers[itemPath]) {
         retryWatchers[itemPath].retryCounter++;
-        src_logger.debug('RETRY_FAILED', {
-            metadata: {
-                itemPath,
-                remainRetries: MAXRETRY - retryWatchers[itemPath].retryCounter,
-                nextRetry: NEXT_RETRY_SECS * retryWatchers[itemPath].retryCounter,
-            },
-        });
+        operator_src_logger.debug(`Failed to process item '${itemPath}'. Retrying in '${NEXT_RETRY_SECS * retryWatchers[itemPath].retryCounter}' seconds. Remaining retries: '${MAXRETRY - retryWatchers[itemPath].retryCounter}'.`);
         retryWatchers[itemPath].retry = false;
         retryWatchers[itemPath].nextRetry = setTimeout(() => {
             if (itemPath in retryWatchers)
@@ -310040,12 +310473,7 @@ async function getItemIfNeededRetry(watcher) {
     }
     catch (e) {
         if (e.message && e.message.includes('Error on getItemByItemPath')) {
-            src_logger.debug('RETRY_ERROR_ITEM_NOT_FOUND', {
-                metadata: {
-                    message: 'item not found, removed from the retry process',
-                    itemPath: watcher.itemPath,
-                },
-            });
+            operator_src_logger.debug(`Item '${watcher.itemPath}' not found, so it has been removed from the retry process.`);
             removeFromRetry(watcher.itemPath);
             return null;
         }
@@ -310085,9 +310513,7 @@ async function resolve(cr, getItemByItemPath, getSecret, namespace = 'default')
 async function resolveSecretRef(namespace, crDependency, getSecret) {
     let secretName = `${crDependency['kind']}-${crDependency['metadata']['name']}-outputs`.toLowerCase();
     if (crDependency.kind === 'FirestartrProviderConfig') {
-        src_logger.debug('RESOLVER_SKIP_SECRET_RESOLUTION_FOR', {
-            metadata: { kind: 'FirestartrProviderConfig', namespace, crDependency },
-        });
+        operator_src_logger.debug(`The resolver is skipping secret resolution for '${crDependency.kind}/${crDependency.metadata.name}' of kind 'FirestartrProviderConfig' in namespace '${namespace}'.`);
         return undefined;
     }
     if (crDependency.kind === 'ExternalSecret') {
@@ -310095,9 +310521,7 @@ async function resolveSecretRef(namespace, crDependency, getSecret) {
     }
     const secret = await getSecret(namespace, secretName);
     if (!secret) {
-        src_logger.error('RESOLVER_SECRET_NOT_SOLVABLE', {
-            metadata: { secretName, crDependency, namespace },
-        });
+        operator_src_logger.error(`The resolver could not find the secret '${secretName}' required by custom resource dependency '${crDependency}' in namespace '${namespace}'.`);
         console.error(`Could not resolve secret ${secretName}`);
     }
     return secret;
@@ -310233,9 +310657,7 @@ const kindsWithFinalizer = [
  */
 async function observeKind(pluralKind, namespace, queue, compute) {
     const lastWorkItems = {};
-    src_logger.info('INFORMER_OBSERVE_START', {
-        metadata: { kind: pluralKind, namespace },
-    });
+    operator_src_logger.info(`The informer has started observing the '${pluralKind}' resource in namespace '${namespace}'.`);
     // onSync
     const enqueueCallback = (event) => {
         return async (item) => {
@@ -310252,13 +310674,7 @@ async function observeKind(pluralKind, namespace, queue, compute) {
     await observe(pluralKind, namespace, 
     // on add
     async (item) => {
-        src_logger.info('INFORMER_ON_ITEM_ADDED', {
-            metadata: {
-                kind: pluralKind,
-                namespace,
-                name: item.metadata.name,
-            },
-        });
+        operator_src_logger.info(`The informer has detected a new item, '${item.metadata.name}', for '${pluralKind}' in namespace '${namespace}'.`);
         await handleUpsertFinalizer(pluralKind, namespace, item);
         const workItem = await inform(pluralKind, item, 'onAdd', getLastWorkItem(pluralKind, lastWorkItems, item));
         syncCtl.addItem(informer_itemPath(pluralKind, item));
@@ -310269,13 +310685,7 @@ async function observeKind(pluralKind, namespace, queue, compute) {
     }, 
     // on modify
     async (item) => {
-        src_logger.info('INFORMER_ON_ITEM_MODIFIED', {
-            metadata: {
-                kind: pluralKind,
-                namespace,
-                name: item.metadata.name,
-            },
-        });
+        operator_src_logger.info(`The informer has detected that item '${item.metadata.name}' for '${pluralKind}' in namespace '${namespace}' was modified.`);
         const workItem = await inform(pluralKind, item, 'onUpdate', getLastWorkItem(pluralKind, lastWorkItems, item));
         if (workItem) {
             setLastWorkItem(pluralKind, lastWorkItems, item, workItem);
@@ -310284,13 +310694,7 @@ async function observeKind(pluralKind, namespace, queue, compute) {
     }, 
     // on delete
     async (item) => {
-        src_logger.info('INFORMER_ON_ITEM_DELETED', {
-            metadata: {
-                kind: pluralKind,
-                namespace,
-                name: item.metadata.name,
-            },
-        });
+        operator_src_logger.info(`The informer has detected that item '${item.metadata.name}' for '${pluralKind}' in namespace '${namespace}' was deleted.`);
         const workItem = await inform(pluralKind, item, 'onMarkedToDeletion', getLastWorkItem(pluralKind, lastWorkItems, item));
         if (workItem) {
             setLastWorkItem(pluralKind, lastWorkItems, item, workItem);
@@ -310300,17 +310704,11 @@ async function observeKind(pluralKind, namespace, queue, compute) {
     }, 
     // on rename
     async (item) => {
-        src_logger.info('INFORMER_ON_ITEM_RENAMED', {
-            metadata: {
-                kind: pluralKind,
-                namespace,
-                name: item.metadata.name,
-            },
-        });
+        operator_src_logger.info(`The informer has detected that an item for '${pluralKind}' in namespace '${namespace}' has been renamed to '${item.metadata.name}'.`);
         const workItem = await inform(pluralKind, item, 'onRename', getLastWorkItem(pluralKind, lastWorkItems, item));
         // Add the renamed item to the sync queue
         syncCtl.addItem(informer_itemPath(pluralKind, item));
-        src_logger.debug('INFORMER_RENAMING_ITEM', { metadata: { workItem } });
+        operator_src_logger.debug(`The informer is renaming item '${workItem.item.metadata.name}' of kind '${workItem.item.kind}' due to a change in its name.`);
         if (workItem) {
             const oldName = workItem.item.metadata.labels[catalog_common.types.controller.FirestartrLabelOldName];
             await handleUnsetFinalizer(pluralKind, namespace, item);
@@ -310371,7 +310769,7 @@ function enqueue(pluralKind, workItem, queue, compute, syncCtl, retryCtl) {
             syncCtl.updateItem(informer_itemPath(pluralKind, item));
         }
         else {
-            src_logger.debug('INFORMER_NOT_SPEC_OPERATION', { metadata: { operation } });
+            operator_src_logger.debug(`The informer received an item with an operation type of '${operation}', which is not a specific operation.`);
         }
     };
     queue(workItem);
@@ -310414,9 +310812,7 @@ async function inform(pluralKind, item, op, lastWorkItem = null) {
             return workItem;
         case 'onRename':
             if (await needsProvisioningOnCreate(item)) {
-                src_logger.debug('INFORMER_ON_RENAME_NEEDS_PROVISION_ON_CREATE', {
-                    metadata: { item },
-                });
+                operator_src_logger.debug(`The informer is triggering a new provisioning process for the renamed item '${item.kind}/${item.metadata.name}'.`);
                 workItem = {
                     operation: OperationType.RENAMED,
                     item,
@@ -310688,15 +311084,7 @@ let INIT = false;
  * @param {WorkItem} workItem - WorkItem to process
  */
 async function processItem(workItem) {
-    src_logger.info('PROCESSOR_NEW_WORKITEM', {
-        metadata: {
-            operation: workItem.operation,
-            workStatus: workItem.workStatus,
-            kind: workItem.item.kind,
-            name: workItem.item.metadata.name,
-            namespace: workItem.item.metadata.namespace,
-        },
-    });
+    operator_src_logger.info(`The processor received a new work item for '${workItem.operation}' operation on '${workItem.item.kind}/${workItem.item.metadata.name}' in namespace '${workItem.item.metadata.namespace}'. Current work status is '${workItem.workStatus}'.`);
     queue.push(workItem);
     if (!INIT) {
         processItem_loop().catch((err) => {
@@ -310717,15 +311105,7 @@ async function processItem_loop() {
             const logMessage = `${new Date().toISOString()} : Processing OPERATION: ${w.operation} ITEM: ${w.item.kind}/${w.item.metadata.name}`;
             catalog_common.io.writeLogFile('process_item', logMessage);
             const timeout = createTimeout(w);
-            src_logger.info('PROCESSOR_PROCESSING_WORKITEM', {
-                metadata: {
-                    operation: w.operation,
-                    workStatus: w.workStatus,
-                    kind: w.item.kind,
-                    name: w.item.metadata.name,
-                    namespace: w.item.metadata.namespace,
-                },
-            });
+            operator_src_logger.info(`The processor is currently handling a '${w.operation}' operation for item '${w.item.kind}/${w.item.metadata.name}' in namespace '${w.item.metadata.namespace}'. The current work status is '${w.workStatus}'.`);
             await runWorkItem(w);
             clearTimeout(timeout);
         }
@@ -310741,15 +311121,7 @@ function createTimeout(w) {
     return setTimeout(() => {
         //throw new Error('Timeout on workitem ' + w);
         console.error('Timeout on workitem %O', w);
-        src_logger.error('PROCESSOR_TIMEOUT_ON_WORKITEM', {
-            metadata: {
-                operation: w.operation,
-                workStatus: w.workStatus,
-                kind: w.item.kind,
-                name: w.item.metadata.name,
-                namespace: w.item.metadata.namespace,
-            },
-        });
+        operator_src_logger.error(`The processor timed out while handling a '${w.operation}' operation for item '${w.item.kind}/${w.item.metadata.name}' in namespace '${w.item.metadata.namespace}'. The current work status is '${w.workStatus}'.`);
         process.exit(1);
     }, TIMEOUTS[w.operation] * 1000);
 }
@@ -310775,7 +311147,7 @@ function processItem_wait(t = 2000) {
     return new Promise((ok) => setTimeout(ok, t));
 }
 async function runWorkItem(workItem) {
-    src_logger.debug('PROCESSOR_RUNNING_WORK_ITEM', { metadata: { workItem } });
+    operator_src_logger.debug(`The processor is now running the '${workItem.operation}' operation for item '${workItem.item.kind}/${workItem.item.metadata.name}' in namespace '${workItem.item.metadata.namespace}'.`);
     if (!workItem.getItem || !workItem.process || !workItem.operation)
         return;
     try {
@@ -310787,33 +311159,17 @@ async function runWorkItem(workItem) {
             await updateTransition(workItem.handler.itemPath(), condition.reason, condition.type, condition.status, condition.message, condition.updateStatusOnly || false);
         }
         workItem.workStatus = WorkStatus.FINISHED;
-        src_logger.debug('PROCESSOR_REMAIN_ITEMS_IN_QUEUE', {
-            metadata: { remainingItems: queue.length },
-        });
+        operator_src_logger.debug(`The processor has '${queue.length}' items remaining in the queue.`);
     }
     catch (e) {
         if (e instanceof Error &&
             e.message.includes('Error on getItemByItemPath')) {
-            src_logger.debug('PROCESSOR_ERROR_ITEM_NOT_FOUND', {
-                metadata: {
-                    workItem,
-                    message: 'item was not found, removing work item from queue',
-                },
-            });
+            operator_src_logger.debug(`Item '${workItem.item.kind}/${workItem.item.metadata.name}' was not found, so its work item is being removed from the processor queue.`);
             workItem.workStatus = WorkStatus.FINISHED;
             return;
         }
         else {
-            src_logger.error('PROCESSOR_ERROR_PROCESSING_WORKITEM', {
-                metadata: {
-                    operation: workItem.operation,
-                    workStatus: workItem.workStatus,
-                    kind: workItem.item.kind,
-                    name: workItem.item.metadata.name,
-                    namespace: workItem.item.metadata.namespace,
-                    error: e,
-                },
-            });
+            operator_src_logger.error(`An error occurred while the processor was handling the '${workItem.operation}' operation for item '${workItem.item.kind}/${workItem.item.metadata.name}' in namespace '${workItem.item.metadata.namespace}'. Current work status is '${workItem.workStatus}'. The error was: '${e}'.`);
             console.error(e);
         }
         return;
@@ -310825,11 +311181,7 @@ async function runWorkItem(workItem) {
  */
 async function workItemGarbageCollector(queue) {
     while (1) {
-        src_logger.debug('PROCESS_ITEM_GARBAGE_COLLECTOR_RUN', {
-            metadata: {
-                workItemsFound: queue.length,
-            },
-        });
+        operator_src_logger.debug(`The garbage collector processed '${queue.length}' work items.`);
         for (const [index, wi] of queue.entries()) {
             if (wi.workStatus === WorkStatus.FINISHED) {
                 // Because the queue is a constant, we cannot reassign it, instead we
@@ -310838,11 +311190,7 @@ async function workItemGarbageCollector(queue) {
                 queue.splice(index, 1);
             }
         }
-        src_logger.debug('PROCESS_ITEM_GARBAGE_COLLECTOR_FINISHED', {
-            metadata: {
-                workItemsLeft: queue.length,
-            },
-        });
+        operator_src_logger.debug(`The garbage collector finished its run, leaving '${queue.length}' work items in the queue.`);
         await processItem_wait(10 * 1000);
     }
 }
@@ -310854,11 +311202,14 @@ if (process.env.GARBAGE_QUEUE_COLLECTOR) {
 var cdktf_lib = __nccwpck_require__(95933);
 // EXTERNAL MODULE: ../../node_modules/@cdktf/provider-github/lib/provider/index.js
 var lib_provider = __nccwpck_require__(95107);
-;// CONCATENATED MODULE: ../provisioner/src/entities/base/Entity.ts
+;// CONCATENATED MODULE: ../provisioner/src/logger.ts
 
+/* harmony default export */ const provisioner_src_logger = (catalog_common.logger);
+
+;// CONCATENATED MODULE: ../provisioner/src/entities/base/Entity.ts
 
-const Entity_log = src_default()('firestartr:provisioner:entity:base');
 const EXTERNAL_NAME_ANNOTATION = 'firestartr.dev/external-name';
+
 class Metadata {
     constructor(metadata) {
         this._metadata = metadata;
@@ -310905,11 +311256,13 @@ class Entity {
     }
     resolveRef(ref, propertyRef) {
         if (!this.deps) {
-            throw `resolveRef:
+            const ErrorMessage = `resolveRef:
 
           Entity with kind ${this.kind} ${this.metadata.name}
 
           does not have any dependencies`;
+            provisioner_src_logger.error(ErrorMessage);
+            throw new Error(ErrorMessage);
         }
         const { kind, name, needsSecret } = ref;
         if (!needsSecret) {
@@ -310918,22 +311271,26 @@ class Entity {
         }
         else {
             if (!propertyRef) {
-                throw `resolveRef:
+                const ErrorMessage = `resolveRef:
 
                 Entity with kind ${this.kind} ${this.metadata.name}
 
                 needs a propertyRef to resolve the secret`;
+                provisioner_src_logger.error(ErrorMessage);
+                throw new Error(ErrorMessage);
             }
             return Buffer.from(this.deps[`${kind}-${name}`].secret.data[propertyRef], 'base64').toString('utf8');
         }
     }
     resolveSecretRef(ref) {
         if (!this.deps) {
-            throw `resolveSecretRef:
+            const ErrorMessage = `resolveSecretRef:
 
           Entity with kind ${this.kind} ${this.metadata.name}
 
           does not have any dependencies`;
+            provisioner_src_logger.error(ErrorMessage);
+            throw new Error(ErrorMessage);
         }
         const { name, key } = ref;
         return Buffer.from(this.deps[`Secret-${name}`].cr.data[key], 'base64').toString('utf8');
@@ -310941,11 +311298,13 @@ class Entity {
     resolveOutputs(scope) {
         if (this.spec.writeConnectionSecretToRef) {
             if (!this.mainResource) {
-                throw `resolveOutputs:
+                const ErrorMessage = `resolveOutputs:
 
             Entity with kind ${this.kind} ${this.metadata.name}
 
             does not have a mainResource`;
+                provisioner_src_logger.error(ErrorMessage);
+                throw new Error(ErrorMessage);
             }
             /**
              * We don't currently support writing outputs to modules
@@ -310955,13 +311314,15 @@ class Entity {
             const keys = this.getKeysFrom(this.mainResource);
             const outputs = this.spec.writeConnectionSecretToRef.outputs;
             for (const o of outputs) {
-                Entity_log('OUTPUT %s', o.key);
+                provisioner_src_logger.debug('OUTPUT %s', o.key);
                 if (!keys.includes(o.key)) {
-                    throw `resolveOutputs:
+                    const ErrorMessage = `resolveOutputs:
 
             Entity with kind ${this.kind} ${this.metadata.name}
 
             does not have the output ${o.key}`;
+                    provisioner_src_logger.error(ErrorMessage);
+                    throw new Error(ErrorMessage);
                 }
                 new cdktf_lib.TerraformOutput(scope, o.key, {
                     value: this.mainResource.getAnyMapAttribute(this.camelToSnake(o.key)),
@@ -310994,7 +311355,6 @@ var repository_file = __nccwpck_require__(79507);
 ;// CONCATENATED MODULE: ../provisioner/src/entities/firestartrgithubrepository/helpers/CodeownersHelper.ts
 
 
-const CodeownersHelper_messageLog = src_default()('firestartr:provisioner:entities:component:helpers:codeownerscreator');
 function provisionCodeowners(scope, repo, branchDefault, fsGithubRepository) {
     const config = {
         dependsOn: [repo, branchDefault],
@@ -311005,7 +311365,7 @@ function provisionCodeowners(scope, repo, branchDefault, fsGithubRepository) {
         overwriteOnCreate: true,
         repository: repo.name,
     };
-    CodeownersHelper_messageLog(`Content of the codeowners:  ${fsGithubRepository.spec.repo.codeowners}`);
+    provisioner_src_logger.debug(`Content of the codeowners:  ${fsGithubRepository.spec.repo.codeowners}`);
     const tfStateKey = `_${fsGithubRepository.getTfStateKey()}-codeowners`;
     new repository_file/* RepositoryFile */.h(scope, tfStateKey, config);
 }
@@ -311018,9 +311378,8 @@ var repository_collaborator = __nccwpck_require__(33786);
 
 
 
-const RepositoryTeamsHelper_messageLog = src_default()('firestartr:provisioner:entities:component:helpers:repositoryteamshelper');
 function provisionPermissions(scope, repo, fsGithubRepository) {
-    RepositoryTeamsHelper_messageLog(`provisionRepositoryTeams with name ${fsGithubRepository.metadata.name} in org ${fsGithubRepository.spec.org}`);
+    provisioner_src_logger.info(`provisionRepositoryTeams with name ${fsGithubRepository.metadata.name} in org ${fsGithubRepository.spec.org}`);
     for (const permission of fsGithubRepository.spec.permissions) {
         if ('ref' in permission) {
             const tfStateKey = `_${fsGithubRepository.getTfStateKey()}-${permission.ref.kind}-${permission.ref.name}-tr`;
@@ -311066,9 +311425,8 @@ var branch_protection_v3 = __nccwpck_require__(31706);
 
 
 
-const RepositoryHelper_messageLog = src_default()('firestartr:provisioner:entities:component:helpers:repositoryhelper');
 function provisionRepository(scope, fsGithubRepository) {
-    RepositoryHelper_messageLog(`provisionRepository with name ${fsGithubRepository.metadata.name} in org ${fsGithubRepository.spec.org}`);
+    provisioner_src_logger.info(`provisionRepository with name ${fsGithubRepository.metadata.name} in org ${fsGithubRepository.spec.org}`);
     const config = {
         name: fsGithubRepository.metadata.name,
         description: fsGithubRepository.spec.repo.description,
@@ -311105,7 +311463,7 @@ function provisionRepository(scope, fsGithubRepository) {
     return repo;
 }
 function provisionBranchProtections(scope, repo, fsGithubRepository) {
-    RepositoryHelper_messageLog(`provisionBranchProtections with name ${fsGithubRepository.metadata.name} in org ${fsGithubRepository.spec.org}`);
+    provisioner_src_logger.info(`provisionBranchProtections with name ${fsGithubRepository.metadata.name} in org ${fsGithubRepository.spec.org}`);
     for (const branchProtection of fsGithubRepository.spec.branchProtections) {
         const tfStateKey = `_${fsGithubRepository.getTfStateKey()}-${branchProtection.pattern}-bp`;
         const statusChecks = {
@@ -311130,8 +311488,6 @@ function provisionBranchProtections(scope, repo, fsGithubRepository) {
 
 ;// CONCATENATED MODULE: ../provisioner/src/config/config.ts
 
-
-const config_messageLog = src_default()('firestartr:provisioner:config');
 /**
  * @description Valid plans for the account
  * @type {Set<string>}
@@ -311238,13 +311594,12 @@ class FirestartrGithubRepository_FirestartrGithubRepository extends Entity {
 
 
 
-const provisioner_messageLog = src_default()('firestartr:provisioner:features:provisioner');
 function provisionFeatureFiles(scope, feature) {
-    provisioner_messageLog(`Provisioning feature ${feature.spec.type} for ${feature.spec.repositoryTarget.name}`);
-    provisioner_messageLog('Feature output json: %O', feature);
+    provisioner_src_logger.info(`Provisioning feature ${feature.spec.type} for ${feature.spec.repositoryTarget.name}`);
+    provisioner_src_logger.debug('Feature output json: %O', feature);
     if (feature.spec.files) {
         for (const file of feature.spec.files) {
-            provisioner_messageLog('Provisioning file %O', file);
+            provisioner_src_logger.debug('Provisioning file %O', file);
             const lifecycleArg = file.userManaged
                 ? { ignoreChanges: ['content'] }
                 : {};
@@ -311279,8 +311634,6 @@ class FirestartrGithubRepositoryFeature_FirestartrGithubRepositoryFeature extend
 var lib_membership = __nccwpck_require__(27501);
 ;// CONCATENATED MODULE: ../provisioner/src/entities/firestartrgithubmembership/helpers/MembershipHelper.ts
 
-
-const MembershipHelper_messageLog = src_default()('firestartr:provisioner:modules:artifacts:userartifact');
 function provisionMembership(scope, fsGithubMembership) {
     const tfStateKey = `_${fsGithubMembership.getTfStateKey()}`;
     const membership = new lib_membership/* Membership */.E(scope, tfStateKey, {
@@ -311295,8 +311648,6 @@ function provisionMembership(scope, fsGithubMembership) {
 var team_membership = __nccwpck_require__(93268);
 ;// CONCATENATED MODULE: ../provisioner/src/entities/firestartrgithubmembership/helpers/MembershipAllGroupHelper.ts
 
-
-const MembershipAllGroupHelper_messageLog = src_default()('firestartr:provisioner:modules:artifacts:membership:all-group-helper');
 function provisionAllGroupMembershipRelation(scope, fsGithubMembership) {
     const tfStateKey = `_${fsGithubMembership.getTfStateKey()}`;
     const config = {
@@ -311327,11 +311678,10 @@ class FirestartrGithubMembership_FirestartrGithubMembership extends Entity {
 var lib_team = __nccwpck_require__(57889);
 ;// CONCATENATED MODULE: ../provisioner/src/entities/firestartrgithubgroup/helpers/TeamsHelper.ts
 
-
 // import { TeamConfigAux } from '../auxiliars/TeamConfigAux';
-const TeamsHelper_messageLog = src_default()('firestartr:provisioner:entities:component:helpers:repositoryhelper');
+
 function provisionGroup(scope, fsGithubGroup) {
-    TeamsHelper_messageLog(`provisionGroup with name ${fsGithubGroup.metadata.name} in org ${fsGithubGroup.spec.org}`);
+    provisioner_src_logger.info(`provisionGroup with name ${fsGithubGroup.metadata.name} in org ${fsGithubGroup.spec.org}`);
     const config = {
         name: fsGithubGroup.metadata.name,
         description: fsGithubGroup.spec.description,
@@ -311349,11 +311699,10 @@ function provisionGroup(scope, fsGithubGroup) {
 ;// CONCATENATED MODULE: ../provisioner/src/entities/firestartrgithubgroup/helpers/TeamMembersHelper.ts
 
 
-const TeamMembersHelper_messageLog = src_default()('firestartr:provisioner:entities:component:helpers:teamsmembershiphelper');
 function provisionMembers(scope, team, fsGithubGroup) {
-    TeamMembersHelper_messageLog(`provisionMembers of group ${fsGithubGroup.metadata.name} in org ${fsGithubGroup.spec.org}`);
+    provisioner_src_logger.info(`provisionMembers of group ${fsGithubGroup.metadata.name} in org ${fsGithubGroup.spec.org}`);
     for (const member of fsGithubGroup.spec.members) {
-        TeamMembersHelper_messageLog(`Provisioning user ${member.ref.name} for group ${fsGithubGroup.metadata.name}`);
+        provisioner_src_logger.info(`Provisioning user ${member.ref.name} for group ${fsGithubGroup.metadata.name}`);
         const tfStateKey = `_${fsGithubGroup.getTfStateKey()}-${member.ref.kind}-${member.ref.name}-tr`;
         if (member.ref.kind === 'FirestartrGithubMembership') {
             const username = fsGithubGroup.resolveRef(member.ref);
@@ -311388,8 +311737,6 @@ class FirestartrGithubGroup_FirestartrGithubGroup extends Entity {
 var organization_webhook = __nccwpck_require__(80516);
 ;// CONCATENATED MODULE: ../provisioner/src/entities/firestartrgithuborgwebhook/helpers/OrgWebhookHelper.ts
 
-
-const OrgWebhookHelper_messageLog = src_default()('firestartr:provisioner:modules:artifacts:orgwebhook');
 function provisionOrgWebhook(scope, fsGithubOrgWebhook) {
     const tfStateKey = `_${fsGithubOrgWebhook.getTfStateKey()}`;
     const webhookConfig = {
@@ -311655,7 +312002,6 @@ var FirestartrTerraformProvider;
 
 
 
-const GithubStack_messageLog = src_default()('firestartr:provisioner:stacks:githubstack');
 class GithubStack extends BaseStack {
     async provisionEntity(isImport, entity, deps, tfStatePath, orgConfig) {
         try {
@@ -311671,7 +312017,7 @@ class GithubStack extends BaseStack {
             }
         }
         catch (err) {
-            GithubStack_messageLog('Error: provisionEntity: %s', err);
+            provisioner_src_logger.error('Error: provisionEntity: %s', err);
             throw err;
         }
     }
@@ -311692,7 +312038,6 @@ class GithubStack extends BaseStack {
 
 
 
-const TerraformModuleStack_messageLog = src_default()('firestartr:provisioner:stacks:terraformmodulestack');
 class TerraformModuleStack extends BaseStack {
     async provisionEntity(isImport, entity, deps, tfStatePath, orgConfig) {
         try {
@@ -311705,7 +312050,7 @@ class TerraformModuleStack extends BaseStack {
             }
         }
         catch (err) {
-            TerraformModuleStack_messageLog('Error: provisionEntity: %s', err);
+            provisioner_src_logger.error('Error: provisionEntity: %s', err);
             throw err;
         }
     }
@@ -311761,9 +312106,10 @@ function __calculateTFStatePath(entity) {
 ;// CONCATENATED MODULE: ../provisioner/src/cdktf.ts
 
 
-async function runCDKTF(entityPath, action, depsPath) {
+async function runCDKTF(entityPath, action, depsPath, stream) {
     return new Promise((ok, ko) => {
         const cdktfProcess = (0,external_child_process_.spawn)('cdktf', [action, '--log-level', 'DEBUG', '--auto-approve'], {
+            stdio: ['inherit', 'pipe', 'pipe'],
             cwd: process.env.IS_DEV_LOCAL_ENVIRONMENT
                 ? '/library/packages/provisioner'
                 : '/library/provisioner',
@@ -311791,10 +312137,14 @@ async function runCDKTF(entityPath, action, depsPath) {
             const logparsed = log.toString();
             if (!logparsed.includes('Synthesizing')) {
                 output += catalog_common.io.stripAnsi(logparsed);
+                if (stream)
+                    stream.write(catalog_common.io.stripAnsi(logparsed));
             }
         });
         cdktfProcess.stderr.on('data', (log) => {
             output += catalog_common.io.stripAnsi(log.toString());
+            if (stream)
+                stream.write(catalog_common.io.stripAnsi(log.toString()));
         });
         cdktfProcess.on('exit', async (code) => {
             if (code !== 0) {
@@ -311812,7 +312162,6 @@ async function runCDKTF(entityPath, action, depsPath) {
 
 
 
-const installer_messageLog = src_default()('firestartr:provisioner:features:installer');
 async function installer_installFeaturesForComponent(component, store) {
     const componentFeatures = component.spec?.provisioner?.features || '[]';
     const componentFeaturesToInstall = componentFeatures.filter((feature) => {
@@ -311821,7 +312170,7 @@ async function installer_installFeaturesForComponent(component, store) {
     });
     if (componentFeaturesToInstall.length > 0) {
         for (const feature of componentFeaturesToInstall) {
-            installer_messageLog('Installing feature %s for component %s', feature.name, component.metadata.name);
+            log.info('Installing feature %s for component %s', feature.name, component.metadata.name);
             // Get feature config
             const featureConfig = common.features.features.getFeatureRenderedConfigForComponent(component, feature.name);
             // prepare files
@@ -311834,7 +312183,7 @@ async function installer_installFeaturesForComponent(component, store) {
         }
     }
     else {
-        installer_messageLog(`No features to install for component ${component.metadata.name}`);
+        log.error(`No features to install for component ${component.metadata.name}`);
     }
     return store;
 }
@@ -311861,7 +312210,7 @@ async function getFileContentFromGithubIfExists(path, repositoryName, owner) {
     }
     catch (e) {
         if (e.status === 404) {
-            installer_messageLog(`File ${path} not found in ${repositoryName}`);
+            log.debug(`File ${path} not found in ${repositoryName}`);
             return false;
         }
         throw e;
@@ -311886,7 +312235,6 @@ function isFreshInstallation(featureName, component) {
 
 
 
-const preparer_messageLog = src_default()('firestartr:provisioner:features:installer');
 async function preparer_prepareFeaturesForComponent(component, store) {
     // those are the features to maintain
     let componentFeatures = component.spec?.provisioner?.features || [];
@@ -311901,7 +312249,7 @@ async function preparer_prepareFeaturesForComponent(component, store) {
     if (componentFeatures.length > 0) {
         const entityPath = dumpArtifactYaml(component);
         for (const feature of componentFeatures) {
-            preparer_messageLog('Installing feature %s for component %s', feature.name, component.metadata.name);
+            log.info('Installing feature %s for component %s', feature.name, component.metadata.name);
             await featuresPreparer.getFeatureConfig(feature.name, feature.version, entityPath);
             // Get feature config
             const featureConfig = common.features.features.getFeatureRenderedConfigForComponent(component, feature.name);
@@ -311925,17 +312273,17 @@ const external_node_readline_namespaceObject = __WEBPACK_EXTERNAL_createRequire(
 
 
 
-const terraform_messageLog = src_default()('firestartr:provisioner:terraform');
-async function runTerraform(entity, command) {
+async function runTerraform(entity, command, stream) {
     let entityID = `${entity.kind.toLowerCase()}--${entity['spec']['firestartr']['tfStateKey']}`;
     if (entity.kind === 'FirestartrGithubRepositoryFeature')
         entityID = `${entity.kind.toLowerCase()}--${entity.metadata.name}`;
     const workDir = external_path_.join(process.env.IS_DEV_LOCAL_ENVIRONMENT
         ? '/library/packages/provisioner'
         : '/library/provisioner', 'cdktf.out', 'stacks', entityID);
-    terraform_messageLog(`Running terraform with command ${command} in ${workDir}`);
+    provisioner_src_logger.info(`Running terraform with command ${command} in ${workDir}`);
     return new Promise((ok, ko) => {
         const terraformProcess = (0,external_child_process_.spawn)('terraform', [...command], {
+            stdio: ['inherit', 'pipe', 'pipe'],
             cwd: workDir,
             env: {
                 PATH: process.env.PATH,
@@ -311953,17 +312301,18 @@ async function runTerraform(entity, command) {
         terraformProcess.stdout.on('data', (log) => {
             const line = catalog_common.io.stripAnsi(log.toString());
             output += line;
-            console.log(line);
+            if (stream)
+                stream.write(line);
         });
         terraformProcess.stderr.on('data', (log) => {
             const line = catalog_common.io.stripAnsi(log.toString());
             output += line;
-            console.log(line);
+            if (stream)
+                stream.write(line);
         });
         terraformProcess.on('exit', async (code) => {
             console.log(`child process exited with code ${code}`);
             if (code !== 0) {
-                console.log(output);
                 ko(output);
             }
             else {
@@ -311972,13 +312321,13 @@ async function runTerraform(entity, command) {
         });
     });
 }
-function terraformInit(entity) {
-    return runTerraform(entity, ['init', '-no-color']);
+function terraformInit(entity, stream) {
+    return runTerraform(entity, ['init', '-no-color'], stream);
 }
-function terraformPlan(entity) {
-    return runTerraform(entity, ['plan', '-no-color']);
+function terraformPlan(entity, stream) {
+    return runTerraform(entity, ['plan', '-no-color'], stream);
 }
-async function terraformApply(entity, isImport = false, skipPlan = false) {
+async function terraformApply(entity, isImport = false, skipPlan = false, stream) {
     let line = false;
     if (isImport && !skipPlan) {
         console.log(`
@@ -311997,15 +312346,15 @@ Type 'yes' to continue:`);
         });
     }
     if (line === 'yes' || skipPlan) {
-        return runTerraform(entity, ['apply', '-no-color', '-auto-approve']);
+        return runTerraform(entity, ['apply', '-no-color', '-auto-approve'], stream);
     }
     else {
         console.log(`🚀 Skipping apply for entity ${entity.kind} ${entity.metadata.name}`);
         return Promise.resolve('');
     }
 }
-function terraformDestroy(entity) {
-    return runTerraform(entity, ['destroy', '-no-color', '-auto-approve']);
+function terraformDestroy(entity, stream) {
+    return runTerraform(entity, ['destroy', '-no-color', '-auto-approve'], stream);
 }
 
 ;// CONCATENATED MODULE: ../provisioner/src/features/uninstaller.ts
@@ -312014,12 +312363,11 @@ function terraformDestroy(entity) {
 
 
 
-const uninstaller_messageLog = src_default()('firestartr:provisioner:features:uninstaller');
 async function untrackManagedFiles(feature, deps) {
     if (!feature.spec.files || feature.spec.files.length < 1)
         return;
-    uninstaller_messageLog('Removing managed files from the Terraform State');
-    uninstaller_messageLog('Synthing the project...');
+    provisioner_src_logger.debug('Removing managed files from the Terraform State');
+    provisioner_src_logger.debug('Synthing the project...');
     const randomFilenameFeature = `${catalog_common.generic.randomString(20)}.yaml`;
     const randomFilenameDeps = `${catalog_common.generic.randomString(20)}_deps.yaml`;
     catalog_common.io.writeYamlFile(randomFilenameFeature, feature, '/tmp');
@@ -312027,7 +312375,7 @@ async function untrackManagedFiles(feature, deps) {
     await runCDKTF(external_path_.join('/tmp', randomFilenameFeature), 'synth', external_path_.join('/tmp', randomFilenameDeps));
     await runTerraform(feature, ['init']);
     for (const file of feature.spec.files.filter((file) => file.userManaged === true)) {
-        uninstaller_messageLog(`Removing from the state file ${file.path}`);
+        provisioner_src_logger.debug(`Removing from the state file ${file.path}`);
         // Terraform replaces / with -- and . with - in the state file names, so we do the same to get the state file name
         const stateFileName = `${feature.spec.type}-${file.path}`
             .replace(/\//g, '--')
@@ -312100,14 +312448,46 @@ function getNextStatus(status) {
 
 
 
+
+
 class Resource {
     setLogger(fn) {
         this.logFn = fn;
     }
+    setSynthStreamLogs(callbacks) {
+        this.synthStreamCallbacks = callbacks;
+    }
+    setTFStreamLogs(callbacks) {
+        this.tfStreamCallbacks = callbacks;
+    }
+    async onSyncStreaming() {
+        if (!this.logStream) {
+            this.logStream = new external_stream_.PassThrough();
+        }
+        if (this.synthStreamCallbacks) {
+            const callbacks = await this.synthStreamCallbacks.prepare();
+            this.setLogStream(callbacks.fnData, callbacks.fnEnd);
+        }
+    }
+    async onTFStreaming() {
+        if (!this.logStream) {
+            this.logStream = new external_stream_.PassThrough();
+        }
+        if (this.tfStreamCallbacks) {
+            const callbacks = await this.tfStreamCallbacks.prepare();
+            this.setLogStream(callbacks.fnData, callbacks.fnEnd);
+        }
+    }
+    setLogStream(fnData, fnEnd, reopen = true) {
+        if (reopen || !this.logStream)
+            this.logStream = new external_stream_.PassThrough();
+        this.logStream.on('data', (data) => fnData(data.toString()));
+        this.logStream.on('end', () => fnEnd());
+    }
     constructor(mainCR, operation, deps = []) {
         this.data = {};
         this.output = '';
-        this.logFn = (msg) => console.log(msg);
+        this.logFn = (msg) => provisioner_src_logger.debug(msg);
         this.set('main_artifact', mainCR);
         this.set('operation', operation);
         this.set('deps', deps);
@@ -312117,36 +312497,46 @@ class Resource {
         await this.synth();
         await this.runTerraform();
         await this.postprocess();
+        if (this.logStream) {
+            this.logStream.end();
+            this.logStream = null;
+        }
     }
     artifact() {
         return this.get('main_artifact');
     }
     async synth() {
+        await this.onSyncStreaming();
         const randomFilenameArtifact = `${catalog_common.generic.randomString(20)}.yaml`;
         const randomFilenameDeps = `${catalog_common.generic.randomString(20)}_deps.yaml`;
         catalog_common.io.writeYamlFile(randomFilenameArtifact, this.get('main_artifact'), '/tmp');
         catalog_common.io.writeYamlFile(randomFilenameDeps, this.get('deps'), '/tmp');
-        await runCDKTF(external_path_.join('/tmp', randomFilenameArtifact), 'synth', external_path_.join('/tmp', randomFilenameDeps));
+        await runCDKTF(external_path_.join('/tmp', randomFilenameArtifact), 'synth', external_path_.join('/tmp', randomFilenameDeps), this.logStream);
+        if (this.logStream) {
+            this.logStream.end();
+            this.logStream = null;
+        }
     }
     log(msg) {
         this.logFn(msg);
     }
     async runTerraform() {
+        await this.onTFStreaming();
         let output = '';
-        output += await terraformInit(this.get('main_artifact'));
-        output += await terraformPlan(this.get('main_artifact'));
+        output += await terraformInit(this.get('main_artifact'), this.logStream);
+        output += await terraformPlan(this.get('main_artifact'), this.logStream);
         if (this.get('operation') === 'CREATE' ||
             this.get('operation') === 'UPDATE') {
-            output += await terraformApply(this.get('main_artifact'), false, true);
+            output += await terraformApply(this.get('main_artifact'), false, true, this.logStream);
         }
         else if (this.get('operation') === 'DELETE') {
-            output += await terraformDestroy(this.get('main_artifact'));
+            output += await terraformDestroy(this.get('main_artifact'), this.logStream);
         }
         else if (this.get('operation') === 'IMPORT') {
-            output += await terraformApply(this.get('main_artifact'), true, false);
+            output += await terraformApply(this.get('main_artifact'), true, false, this.logStream);
         }
         else if (this.get('operation') === 'IMPORT_SKIP_PLAN') {
-            output += await terraformApply(this.get('main_artifact'), true, true);
+            output += await terraformApply(this.get('main_artifact'), true, true, this.logStream);
         }
         else {
             throw new Error(`unknown operation: ${this.get('operation')}`);
@@ -312171,7 +312561,6 @@ class Resource {
 
 
 
-const github_feature_log = src_default()('firestartr:provisioner:github_repository_feature');
 class github_feature_FirestartrGithubRepositoryFeature extends Resource {
     static kind() {
         return 'FirestartrGithubRepositoryFeature';
@@ -312179,19 +312568,19 @@ class github_feature_FirestartrGithubRepositoryFeature extends Resource {
     async preprocess() {
         switch (this.get('operation')) {
             case 'CREATE':
-                github_feature_log('CREATED');
+                provisioner_src_logger.debug('Creating FirestartrGithubRepositoryFeature');
                 await this._updateManagedFiles();
                 break;
             case 'UPDATE':
-                github_feature_log('UPDATED');
+                provisioner_src_logger.debug('Updating FirestartrGithubRepositoryFeature');
                 await this._updateManagedFiles();
                 break;
             case 'DELETE':
-                github_feature_log('DELETE');
+                provisioner_src_logger.debug('Deleting FirestartrGithubRepositoryFeature');
                 await untrackManagedFiles(this.get('main_artifact'), this.get('deps'));
                 break;
             default:
-                github_feature_log(`UNKNOWN: ${this.get('operation')}`);
+                provisioner_src_logger.debug(`Unknown operation '${this.get('operation')}' for FirestartrGithubRepositoryFeature`);
         }
     }
     async _updateManagedFiles() {
@@ -312205,7 +312594,7 @@ class github_feature_FirestartrGithubRepositoryFeature extends Resource {
                     file.content = newContent;
                 }
                 catch (e) {
-                    github_feature_log(`File ${file.path} not found in repo ${repoInfo.ref.name} on branch ${repoInfo.branch}. File content not updated`);
+                    provisioner_src_logger.error(`File ${file.path} not found in repo ${repoInfo.ref.name} on branch ${repoInfo.branch}. File content not updated`);
                 }
             }
         }
@@ -312285,7 +312674,6 @@ async function provisionRegularBranch(repo, branchName, sourceBranch, org) {
 
 
 
-const github_repository_log = src_default()('firestartr:provisioner:github_repository');
 class github_repository_FirestartrGithubRepository extends Resource {
     static kind() {
         return 'FirestartrGithubRepository';
@@ -312293,22 +312681,23 @@ class github_repository_FirestartrGithubRepository extends Resource {
     async preprocess() {
         switch (this.get('operation')) {
             case 'CREATE':
-                github_repository_log('CREATE');
+                provisioner_src_logger.debug('Creating FirestartrGithubRepository');
                 break;
             case 'UPDATE':
-                github_repository_log('UPDATED');
+                provisioner_src_logger.debug('Updating FirestartrGithubRepository');
                 break;
             case 'DELETE':
-                github_repository_log('DELETED');
+                provisioner_src_logger.debug('Deleted FirestartrGithubRepository');
                 break;
             case 'IMPORT':
-                github_repository_log('IMPORT');
+                provisioner_src_logger.debug('Importing FirestartrGithubRepository');
                 break;
             case 'IMPORT_SKIP_PLAN':
-                github_repository_log('IMPORT_SKIP_PLAN');
+                provisioner_src_logger.debug('Import skipping plan for FirestartrGithubRepository');
                 break;
             default:
-                github_repository_log('UNKNOWN');
+                provisioner_src_logger.debug('Unknown operation for FirestartrGithubRepository ' +
+                    this.get('operation'));
         }
     }
     async postprocess() {
@@ -312316,20 +312705,20 @@ class github_repository_FirestartrGithubRepository extends Resource {
         switch (this.get('operation')) {
             case 'CREATE':
             case 'UPDATE':
-                github_repository_log('CREATE & UPDATE');
+                provisioner_src_logger.debug(`Created and updated FirestartrGithubRepository ${cr.metadata.name}`);
                 await provisionAdditionalBranches(cr);
                 break;
             case 'DELETE':
-                github_repository_log('DELETED');
+                provisioner_src_logger.debug(`Deleted FirestartrGithubRepository ${cr.metadata.name}`);
                 break;
             case 'IMPORT':
-                github_repository_log('IMPORT');
+                provisioner_src_logger.debug(`Imported FirestartrGithubRepository ${cr.metadata.name}`);
                 break;
             case 'IMPORT_SKIP_PLAN':
-                github_repository_log('IMPORT_SKIP_PLAN');
+                provisioner_src_logger.debug(`Imported skipped plan FirestartrGithubRepository ${cr.metadata.name}`);
                 break;
             default:
-                github_repository_log('UNKNOWN');
+                provisioner_src_logger.debug(`Finished for unknown operation ${this.get('operation')} for FirestartrGithubRepository`);
         }
     }
 }
@@ -312337,7 +312726,6 @@ class github_repository_FirestartrGithubRepository extends Resource {
 ;// CONCATENATED MODULE: ../provisioner/src/resources/github_membership/index.ts
 
 
-const github_membership_log = src_default()('firestartr:provisioner:github_membership');
 class github_membership_FirestartrGithubMembership extends Resource {
     static kind() {
         return 'FirestartrGithubMembership';
@@ -312345,22 +312733,23 @@ class github_membership_FirestartrGithubMembership extends Resource {
     async preprocess() {
         switch (this.get('operation')) {
             case 'CREATE':
-                github_membership_log('CREATE');
+                provisioner_src_logger.debug('Creating FirestartrGithubMembership');
                 break;
             case 'UPDATE':
-                github_membership_log('UPDATED');
+                provisioner_src_logger.debug('Updating FirestartrGithubMembership');
                 break;
             case 'DELETE':
-                github_membership_log('DELETED');
+                provisioner_src_logger.debug('Deleted FirestartrGithubMembership');
                 break;
             case 'IMPORT':
-                github_membership_log('IMPORT');
+                provisioner_src_logger.debug('Importing FirestartrGithubMembership');
                 break;
             case 'IMPORT_SKIP_PLAN':
-                github_membership_log('IMPORT_SKIP_PLAN');
+                provisioner_src_logger.debug('Import skipping plan for FirestartrGithubMembership');
                 break;
             default:
-                github_membership_log('UNKNOWN');
+                provisioner_src_logger.debug('Unknown operation for FirestartrGithubMembership ' +
+                    this.get('operation'));
         }
     }
 }
@@ -312368,7 +312757,6 @@ class github_membership_FirestartrGithubMembership extends Resource {
 ;// CONCATENATED MODULE: ../provisioner/src/resources/github_group/index.ts
 
 
-const github_group_log = src_default()('firestartr:provisioner:github_group');
 class github_group_FirestartrGithubGroup extends Resource {
     static kind() {
         return 'FirestartrGithubGroup';
@@ -312376,22 +312764,23 @@ class github_group_FirestartrGithubGroup extends Resource {
     async preprocess() {
         switch (this.get('operation')) {
             case 'CREATE':
-                github_group_log('CREATE');
+                provisioner_src_logger.debug('Creating FirestartrGithubGroup');
                 break;
             case 'UPDATE':
-                github_group_log('UPDATED');
+                provisioner_src_logger.debug('Updating FirestartrGithubGroup');
                 break;
             case 'DELETE':
-                github_group_log('DELETED');
+                provisioner_src_logger.debug('Deleted FirestartrGithubGroup');
                 break;
             case 'IMPORT':
-                github_group_log('IMPORT');
+                provisioner_src_logger.debug('Importing FirestartrGithubGroup');
                 break;
             case 'IMPORT_SKIP_PLAN':
-                github_group_log('IMPORT_SKIP_PLAN');
+                provisioner_src_logger.debug('Import skipping plan for FirestartrGithubGroup');
                 break;
             default:
-                github_group_log('UNKNOWN');
+                provisioner_src_logger.debug('Unknown operation for FirestartrGithubGroup ' +
+                    this.get('operation'));
         }
     }
 }
@@ -312399,14 +312788,13 @@ class github_group_FirestartrGithubGroup extends Resource {
 ;// CONCATENATED MODULE: ../provisioner/src/resources/terraform_module/index.ts
 
 
-const terraform_module_log = src_default()('firestartr:provisioner:terraform_module');
 class FirestartrTerraformModule extends Resource {
     static kind() {
         return 'FirestartrTerraformModule';
     }
     async preprocess() {
         const operation = this.get('operation');
-        terraform_module_log(operation);
+        provisioner_src_logger.debug(`Running operation '${operation}' for FirestartrTerraformModule`);
         switch (operation) {
             case 'CREATE':
                 break;
@@ -312427,7 +312815,6 @@ class FirestartrTerraformModule extends Resource {
 ;// CONCATENATED MODULE: ../provisioner/src/resources/github_orgWebhook/index.ts
 
 
-const github_orgWebhook_log = src_default()('firestartr:provisioner:github_orgWebhook');
 class github_orgWebhook_FirestartrGithubOrgWebhook extends Resource {
     static kind() {
         return 'FirestartrGithubOrgWebhook';
@@ -312435,22 +312822,23 @@ class github_orgWebhook_FirestartrGithubOrgWebhook extends Resource {
     async preprocess() {
         switch (this.get('operation')) {
             case 'CREATE':
-                github_orgWebhook_log('CREATE');
+                provisioner_src_logger.debug('Creating FirestartrGithubOrgWebhook');
                 break;
             case 'UPDATE':
-                github_orgWebhook_log('UPDATED');
+                provisioner_src_logger.debug('Updating FirestartrGithubOrgWebhook');
                 break;
             case 'DELETE':
-                github_orgWebhook_log('DELETED');
+                provisioner_src_logger.debug('Deleted FirestartrGithubOrgWebhook');
                 break;
             case 'IMPORT':
-                github_orgWebhook_log('IMPORT');
+                provisioner_src_logger.debug('Importing FirestartrGithubOrgWebhook');
                 break;
             case 'IMPORT_SKIP_PLAN':
-                github_orgWebhook_log('IMPORT_SKIP_PLAN');
+                provisioner_src_logger.debug('Import skipping plan for FirestartrGithubOrgWebhook');
                 break;
             default:
-                github_orgWebhook_log('UNKNOWN');
+                provisioner_src_logger.debug('Unknown operation for FirestartrGithubOrgWebhook ' +
+                    this.get('operation'));
         }
     }
 }
@@ -312487,6 +312875,12 @@ async function runProvisioner(data, opts) {
                         ? 'DELETE'
                         : 'UNKNOWN';
     const resource = createInstanceOf(mainCr, operation, deps);
+    if ('logStreamCallbacksCDKTF' in opts) {
+        resource.setSynthStreamLogs(opts['logStreamCallbacksCDKTF']);
+    }
+    if ('logStreamCallbacksTF' in opts) {
+        resource.setTFStreamLogs(opts['logStreamCallbacksTF']);
+    }
     await resource.run();
     return resource;
 }
@@ -312505,7 +312899,6 @@ function createInstanceOf(entity, op, deps) {
 
 
 
-const provisioner_messageLog_0 = src_default()('firestartr:provisioner:main');
 async function deploy(app) {
     const entity = catalog_common.io.fromYaml(external_fs_.readFileSync(catalog_common.environment.getFromEnvironment(catalog_common.types.envVars.cdktfEntityPath), 'utf8'));
     const deps = catalog_common.io.fromYaml(external_fs_.readFileSync(catalog_common.environment.getFromEnvironment(catalog_common.types.envVars.cdktfDepsPath), 'utf8'));
@@ -312514,7 +312907,7 @@ async function deploy(app) {
         : false;
     catalog_common.io.removeFile(catalog_common.environment.getFromEnvironment(catalog_common.types.envVars.cdktfEntityPath));
     catalog_common.io.removeFile(catalog_common.environment.getFromEnvironment(catalog_common.types.envVars.cdktfDepsPath));
-    provisioner_messageLog_0('Entity to provision: %O', entity);
+    provisioner_src_logger.info(`Entity to provision: ${entity}`);
     const orgConfig = {
         bucket: catalog_common.environment.getFromEnvironment(catalog_common.types.envVars.s3Bucket),
         dynamodbTable: catalog_common.environment.getFromEnvironment(catalog_common.types.envVars.s3Lock),
@@ -312532,7 +312925,7 @@ async function deploy(app) {
         app.synth();
     }
     catch (e) {
-        void provisioner_messageLog_0('Error: deploy: %s', e);
+        provisioner_src_logger.error('Error: deploy: %s', e);
         throw e;
     }
 }
@@ -312554,26 +312947,20 @@ if (process.env.RUN_PROVISIONER) {
 async function tryPublishApply(item, planOutput, kind) {
     try {
         if (!('firestartr.dev/last-state-pr' in item.metadata.annotations)) {
-            src_logger.debug('USER_FEEDBACK_PUBLISH_APPLY_NO_LAST_STATE', {
-                metadata: { name: item.metadata.name, kind },
-            });
+            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);
     }
     catch (e) {
-        src_logger.error('USER_FEEDBACK_PUBLISH_APPLY_ERROR', {
-            metadata: { name: item.metadata.name, kind, error: 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) {
     let lastPr = null;
     try {
         const { repo, org } = extractPrInfo(item);
-        src_logger.debug('USER_FEEDBACK_PUBLISH_DESTROY', {
-            metadata: { item, repo, org },
-        });
+        operator_src_logger.debug(`The user feedback for the '${item.kind}/${item.metadata.name}' destroy operation is being published for repository '${repo}' in organization '${org}'.`);
         lastPr = await github_0.pulls.filterPrBy({
             title: `hydrate: ${item.metadata.name}`,
             state: 'closed',
@@ -312584,9 +312971,7 @@ async function tryPublishDestroy(item, destroyOutput) {
             maxRetries: 3,
         });
         if (!lastPr) {
-            src_logger.debug('USER_FEEDBACK_PUBLISH_DESTROY_NO_LAST_STATE', {
-                metadata: { item },
-            });
+            operator_src_logger.debug(`The user feedback for the '${item.kind}/${item.metadata.name}' destroy operation could not be published because the last state was not found.`);
             return;
         }
         const dividedOutput = github_0.pulls.divideCommentIntoChunks(destroyOutput, 250);
@@ -312604,20 +312989,14 @@ async function tryPublishDestroy(item, destroyOutput) {
 ${commentContent}
 \`\`\`
 </details>`;
-            src_logger.debug('USER_FEEDBACK_PUBLISH_COMMENT', {
-                metadata: { lastPr: lastPr.number, repo, org, item },
-            });
+            operator_src_logger.debug(`The user feedback for item '${item.kind}/${item.metadata.name}' is being published as a comment on pull request '${lastPr.number}' for repository '${repo}' in organization '${org}'.`);
             await github_0.pulls.commentInPR(comment, lastPr.number, repo, org);
-            src_logger.debug('USER_FEEDBACK_PUBLISH_DESTROY_COMMENT', {
-                metadata: { lastPr: lastPr.number, item },
-            });
+            operator_src_logger.debug(`The user feedback for the '${item.kind}/${item.metadata.name}' destroy operation is being published as a comment on pull request '${lastPr.number}'.`);
             currentCommentNo += 1;
         }
     }
     catch (e) {
-        src_logger.error('USER_FEEDBACK_PUBLISH_ERROR', {
-            metadata: { lastPr: lastPr.number, item, error: e },
-        });
+        operator_src_logger.error(`An error occurred while publishing user feedback for item '${item.kind}/${item.metadata.name}' on pull request '${lastPr.number}': '${e}'.`);
     }
 }
 async function publishApply(item, applyOutput, kind) {
@@ -312654,9 +313033,7 @@ function tryCreateErrorSummary(title, errorMsg) {
         return summaryText;
     }
     catch (e) {
-        src_logger.error('USER_FEEDBACK_GETTING_ERROR_SUMMARY', {
-            metadata: { error: e, title, errorMsg },
-        });
+        operator_src_logger.error(`An error occurred while getting the error summary for '${title}'. The error was '${e}', with the message: '${errorMsg}'.`);
         return `Error when getting error summary: ${e}`;
     }
 }
@@ -312678,9 +313055,7 @@ async function tryPublishError(item, reason, message) {
         await publishError(item, reason, message);
     }
     catch (e) {
-        src_logger.error('USER_FEEDBACK_TRY_PUBLISH_ERROR', {
-            metadata: { item, error: e, reason },
-        });
+        operator_src_logger.error(`The user feedback for item '${item.kind}/${item.metadata.name}' failed to publish due to an error: '${e}'. Reason: '${reason}'.`);
     }
 }
 async function publishError(item, reason, message) {
@@ -312718,6 +313093,53 @@ ${commentContent}
     }
 }
 
+;// CONCATENATED MODULE: ../operator/src/user-feedback-ops/gh-checkrun.ts
+
+async function GHCheckRun(cmd, item) {
+    const prInfo = gh_checkrun_extractPrInfo(item);
+    if (!prInfo.prNumber) {
+        throw new Error('TFCheckRun: prNumber not retrievable');
+    }
+    const checkRun = await github_0.feedback.createCheckRun(prInfo.org, prInfo.repo, helperCreateCheckRunName(cmd, item), {
+        //Number(pr_number),
+        pullNumber: Number(prInfo.prNumber),
+        includeCheckRunComment: true,
+        checkRunComment: `The Github ${item.kind} is being processed (cmd=${cmd}). Details: `,
+    });
+    checkRun.mdOptionsDetails({
+        quotes: 'terraform',
+    });
+    checkRun.update('Initiating', 'queued');
+    return {
+        fnData: (d) => {
+            checkRun.update(d.toString(), 'in_progress');
+        },
+        fnEnd: () => {
+            checkRun.close('OK', true);
+        },
+        fnOnError: (err) => {
+            checkRun.close('KO', false);
+        },
+    };
+}
+function helperCreateCheckRunName(cmd, item) {
+    return `Github Provisioner / ${item.kind} - ${cmd}`;
+}
+function gh_checkrun_extractPrInfo(item) {
+    const prInfo = item.metadata.annotations['firestartr.dev/last-state-pr'];
+    const prNumber = prInfo.split('#')[1];
+    if (!prNumber)
+        throw new Error('No PR number found in CR');
+    const orgRepo = prInfo.split('#')[0];
+    const org = orgRepo.split('/')[0];
+    if (!org)
+        throw new Error('No org found in CR');
+    const repo = orgRepo.split('/')[1];
+    if (!repo)
+        throw new Error('No repo found in CR');
+    return { prNumber, repo, org };
+}
+
 ;// CONCATENATED MODULE: ../operator/cdktf.ts
 
 
@@ -312727,8 +313149,8 @@ ${commentContent}
 
 
 
-const cdktf_log = src_default()('firestartr:operator:cdktf');
 function processOperation(item, op, handler) {
+    operator_src_logger.info(`Processing operation ${op} on ${item.kind}/${item.metadata?.name}`);
     try {
         switch (op) {
             case OperationType.UPDATED:
@@ -312750,7 +313172,7 @@ function processOperation(item, op, handler) {
         }
     }
     catch (e) {
-        cdktf_log(`Operation ${op} failed: ${e}`);
+        operator_src_logger.error(`Operation ${op} failed: ${e}`);
         throw e;
     }
 }
@@ -312801,6 +313223,9 @@ async function* sync(item, op, handler) {
     };
 }
 async function* markedToDeletion(item, op, handler) {
+    // here we store the current callbacks that
+    // are being used (synth|tf-apply...)
+    let checkRunCtl;
     try {
         void cleanTerraformState();
         const type = 'DELETING';
@@ -312825,15 +313250,38 @@ async function* markedToDeletion(item, op, handler) {
             status: 'True',
             message: 'Destroying process started',
         };
-        if (item.metadata.annotations['firestartr.dev/last-state-pr'] || false) {
-            await addDestroyCommitStatus(item, 'pending', 'Performing destroy operation...', `Terraform Destroy ${item.metadata.name}`);
-        }
         const deps = await handler.resolveReferences();
+        const annotation = 'firestartr.dev/last-state-pr';
+        const statePr = item?.metadata?.annotations?.[annotation];
+        const hasStatePr = typeof statePr === 'string' && statePr.trim().length > 0;
+        if (!hasStatePr) {
+            operator_src_logger.warn(`CR ${item?.kind ?? 'UnknownKind'}/${item?.metadata?.name ?? 'unknown'} ` +
+                `has no "${annotation}" annotation; skipping GitHub Check Runs (synth, terraform apply).`);
+        }
+        else {
+            operator_src_logger.debug(`CR ${item.kind}/${item.metadata.name} uses "${annotation}" = ${statePr}`);
+        }
         const destroyOutput = await provisioner.runProvisioner({
             mainCr: item,
             deps,
         }, {
             delete: true,
+            ...(hasStatePr
+                ? {
+                    logStreamCallbacksCDKTF: {
+                        prepare: async () => {
+                            checkRunCtl = await GHCheckRun('synth', item);
+                            return checkRunCtl;
+                        },
+                    },
+                    logStreamCallbacksTF: {
+                        prepare: async () => {
+                            checkRunCtl = await GHCheckRun('terraform destroy', item);
+                            return checkRunCtl;
+                        },
+                    },
+                }
+                : {}),
         });
         const output = destroyOutput.output;
         await tryPublishDestroy(item, output);
@@ -312859,10 +313307,11 @@ async function* markedToDeletion(item, op, handler) {
             status: 'True',
             message: e.toString(),
         };
+        // if there is a current checkRun working
+        // we close it with an error
+        if (checkRunCtl)
+            checkRunCtl.fnOnError(e);
         await handler.writeTerraformOutputInTfResult(item, e);
-        if (item.metadata.annotations['firestartr.dev/last-state-pr'] || false) {
-            await addDestroyCommitStatus(item, 'failure', 'Destroy operation failed', `Terraform Destroy ${item.metadata.name}`);
-        }
         void handler.error();
     }
 }
@@ -312881,6 +313330,9 @@ async function* nothing(item, op, handler) {
  * @param handler -
  */
 async function* doApply(item, op, handler) {
+    // here we store the current callbacks that
+    // are being used (synth|tf-apply...)
+    let checkRunCtl;
     try {
         cleanTerraformState();
         yield {
@@ -312922,16 +313374,41 @@ async function* doApply(item, op, handler) {
             opts['create'] = true;
         }
         const deps = await handler.resolveReferences();
-        cdktf_log('Item %s has the following dependencies: %O', item.metadata.name, deps);
-        if (item.metadata.annotations['firestartr.dev/last-state-pr'] || false) {
-            await addApplyCommitStatus(item, 'pending', catalog_common.generic.getPrLinkFromAnnotationValue(item.metadata.annotations['firestartr.dev/last-state-pr']), 'Performing apply operation...', `Terraform Apply ${item.metadata.name}`);
+        operator_src_logger.info(`Item ${item.metadata.name} has the following dependencies: ${deps}`);
+        const annotation = 'firestartr.dev/last-state-pr';
+        const statePr = item?.metadata?.annotations?.[annotation];
+        const hasStatePr = typeof statePr === 'string' && statePr.trim().length > 0;
+        if (!hasStatePr) {
+            operator_src_logger.warn(`CR ${item?.kind ?? 'UnknownKind'}/${item?.metadata?.name ?? 'unknown'} ` +
+                `has no "${annotation}" annotation; skipping GitHub Check Runs (synth, terraform apply).`);
+        }
+        else {
+            operator_src_logger.debug(`CR ${item.kind}/${item.metadata.name} uses "${annotation}" = ${statePr}`);
         }
         const applyOutput = await provisioner.runProvisioner({
             mainCr: item,
             deps,
-        }, opts);
+        }, {
+            ...opts,
+            ...(hasStatePr
+                ? {
+                    logStreamCallbacksCDKTF: {
+                        prepare: async () => {
+                            checkRunCtl = await GHCheckRun('synth', item);
+                            return checkRunCtl;
+                        },
+                    },
+                    logStreamCallbacksTF: {
+                        prepare: async () => {
+                            checkRunCtl = await GHCheckRun('terraform apply', item);
+                            return checkRunCtl;
+                        },
+                    },
+                }
+                : {}),
+        });
         await tryPublishApply(item, applyOutput?.data?.output, item.kind);
-        const terraformOutputJson = await provisioner.runTerraform(item, ['output', '-json']);
+        const terraformOutputJson = await provisioner.runTerraform(item, ['output', '-json'], null);
         if (!terraformOutputJson) {
             throw new Error(`Terraform output is empty for ${item.kind}/${item.metadata.name}`);
         }
@@ -312959,9 +313436,6 @@ async function* doApply(item, op, handler) {
             message: 'doApply',
         };
         await handler.writeTerraformOutputInTfResult(item, output);
-        if (item.metadata.annotations['firestartr.dev/last-state-pr'] || false) {
-            await addApplyCommitStatus(item, 'success', catalog_common.generic.getPrLinkFromAnnotationValue(item.metadata.annotations['firestartr.dev/last-state-pr']), 'Apply operation completed', `Terraform Apply ${item.metadata.name}`);
-        }
         handler.success();
     }
     catch (e) {
@@ -312973,7 +313447,11 @@ async function* doApply(item, op, handler) {
             error = e;
         }
         await tryPublishApply(item, error, item.kind);
-        cdktf_log('Error applying item %s: %O', item.metadata.name, error);
+        // if there is a current checkRun working
+        // we close it with an error
+        if (checkRunCtl)
+            checkRunCtl.fnOnError(error);
+        operator_src_logger.error(`Error applying item ${item.metadata.name}: ${error}`);
         yield {
             item,
             reason: op,
@@ -312995,9 +313473,6 @@ async function* doApply(item, op, handler) {
             status: 'False',
             message: error.toString(),
         };
-        if (item.metadata.annotations['firestartr.dev/last-state-pr'] || false) {
-            await addApplyCommitStatus(item, 'failure', catalog_common.generic.getPrLinkFromAnnotationValue(item.metadata.annotations['firestartr.dev/last-state-pr']), 'Apply operation failed', `Terraform Apply ${item.metadata.name}`);
-        }
         handler.error();
         if (error) {
             await handler.writeTerraformOutputInTfResult(item, error);
@@ -313114,57 +313589,72 @@ class TFPlanItemVersion extends TFPlanItem {
     }
 }
 
+;// CONCATENATED MODULE: ../terraform_provisioner/src/logger.ts
+
+/* harmony default export */ const terraform_provisioner_src_logger = (catalog_common.logger);
+
 ;// CONCATENATED MODULE: ../terraform_provisioner/src/utils.ts
 
 
-//import Debug from "debug"
 
-//const infolog: Debug.Debugger = Debug('firestartr:operator:cmd:terraform')
+
 async function utils_validate(path, secrets) {
     return await tfExec(path, ['validate'], secrets);
 }
-async function init(path, secrets) {
-    return await tfExec(path, ['init'], secrets);
+async function init(path, secrets, stream) {
+    return await tfExec(path, ['init'], secrets, ['-input=false'], stream);
 }
-async function initFromModule(path, source, secrets) {
-    return tfExec(path, ['init', `-from-module=${source}`], secrets, []);
+async function initFromModule(path, source, secrets, stream) {
+    return tfExec(path, ['init', `-from-module=${source}`], secrets, [], stream);
 }
-async function plan(path, secrets, format, args = ['plan']) {
-    const plan = await tfExec(path, args.concat(format === 'json' ? ['-json'] : []), secrets);
+async function plan(path, secrets, format, args = ['plan'], stream) {
+    terraform_provisioner_src_logger.info(`Running terraform plan with ${format} in path ${path}`);
+    const plan = await tfExec(path, args.concat(format === 'json' ? ['-json'] : []), secrets, ['-input=false'], stream);
     if (format === 'json') {
         const tfPlan = planGet(plan);
         return tfPlan;
     }
     return plan;
 }
-async function apply(path, secrets) {
-    return await tfExec(path, ['apply', '-auto-approve'], secrets);
+async function apply(path, secrets, stream) {
+    terraform_provisioner_src_logger.debug(`Running terraform apply in path ${path}`);
+    return await tfExec(path, ['apply', '-auto-approve'], secrets, ['-input=false'], stream);
 }
-async function destroy(path, secrets) {
-    return await tfExec(path, ['destroy', '-auto-approve'], secrets);
+async function destroy(path, secrets, stream) {
+    terraform_provisioner_src_logger.debug(`Running terraform destroy in path ${path}`);
+    return await tfExec(path, ['destroy', '-auto-approve'], secrets, ['-input=false'], stream);
 }
 async function output(path, secrets) {
+    terraform_provisioner_src_logger.debug(`Running terraform output in path ${path}`);
     return await tfExec(path, ['output', '-json'], secrets, []);
 }
-async function tfExec(path, args, secrets, extraArgs = ['-input=false']) {
+async function tfExec(path, args, secrets, extraArgs = ['-input=false'], stream) {
     // Format to TF_VAR variables -> https://developer.hashicorp.com/terraform/cli/config/environment-variables#tf_var_name
     for (const secret of secrets) {
         process.env[`${secret.key}`] = secret.value;
     }
+    terraform_provisioner_src_logger.info(`Spawning terraform process ['terraform ${args.concat(extraArgs).join(' ')}'] in path '${path}'`);
     process.env['TF_PLUGIN_CACHE_DIR'] = '/home/terraform-plugins-cache';
     return new Promise((ok, ko) => {
-        const tfProcess = (0,external_child_process_.spawn)('terraform', args.concat(extraArgs), { cwd: path });
-        tfProcess.stdout.pipe(process.stdout);
-        tfProcess.stderr.pipe(process.stderr);
+        const tfProcess = (0,external_child_process_.spawn)('terraform', args.concat(extraArgs), {
+            cwd: path,
+            stdio: ['inherit', 'pipe', 'pipe'],
+        });
         let output = '';
         let flagStdoutEnd = false;
         let flagStderrEnd = false;
         let outputErrors = '';
         tfProcess.stdout.on('data', (log) => {
-            output += catalog_common.io.stripAnsi(log.toString());
+            const line = catalog_common.io.stripAnsi(log.toString());
+            output += line;
+            if (stream)
+                stream.write(line);
         });
         tfProcess.stderr.on('data', (log) => {
-            outputErrors += catalog_common.io.stripAnsi(log.toString());
+            const line = catalog_common.io.stripAnsi(log.toString());
+            outputErrors += line;
+            if (stream)
+                stream.write(line);
         });
         tfProcess.stdout.on('end', () => {
             flagStdoutEnd = true;
@@ -313179,9 +313669,12 @@ async function tfExec(path, args, secrets, extraArgs = ['-input=false']) {
                 await catalog_common.generic.sleep(500);
             }
             if (code !== 0) {
-                ko(output + outputErrors);
+                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(''));
             }
             else {
+                terraform_provisioner_src_logger.info(`Terraform output ${path}: ${output}`);
                 ok(output);
             }
         });
@@ -313195,7 +313688,9 @@ async function configureGit(ghToken) {
             'url."https://' + ghToken + '@github.com".insteadOf',
             'https://github.com',
         ];
-        const gitProcess = spawn('git', options);
+        const gitProcess = spawn('git', options, {
+            stdio: ['inherit', 'pipe', 'pipe'],
+        });
         let output = '';
         gitProcess.on('data', (log) => {
             output += common.io.stripAnsi(log.toString());
@@ -313550,6 +314045,7 @@ function fCheckString(keys, refs) {
 
 
 
+
 class project_tf_TFProjectManager {
     constructor(ctx) {
         this.tfOutput = '';
@@ -313558,6 +314054,14 @@ class project_tf_TFProjectManager {
         this.tfVarsJsonWriter = new WriterTfVarsJson(ctx.values, ctx.references);
         this.secrets = ctx.secrets;
     }
+    setStreamCallbacks(fnData, fnEnd, reopen = true) {
+        if (reopen || !this.stream)
+            this.stream = new external_stream_.PassThrough();
+        this.stream.on('data', (data) => {
+            fnData(data.toString());
+        });
+        this.stream.on('end', fnEnd);
+    }
     getOutput() {
         return this.tfOutput;
     }
@@ -313568,10 +314072,10 @@ class project_tf_TFProjectManager {
         this.tfVarsJsonWriter.writeToTerraformProject(external_path_.join(this.projectPath, 'terraform.tfvars.json'));
     }
     async __init() {
-        this.tfOutput += await init(this.projectPath, this.secrets);
+        this.tfOutput += await init(this.projectPath, this.secrets, this.stream);
     }
     async __initFromModule() {
-        this.tfOutput += await init(this.projectPath, this.secrets);
+        this.tfOutput += await init(this.projectPath, this.secrets, this.stream);
     }
     async validate() {
         await this.__init();
@@ -313581,24 +314085,27 @@ class project_tf_TFProjectManager {
         await this.__init();
         if (format === 'json')
             this.tfOutput = null;
-        this.tfOutput = await plan(this.projectPath, this.secrets, format);
+        this.tfOutput = await plan(this.projectPath, this.secrets, format, ['plan'], this.stream);
+        if (this.stream)
+            this.stream.end();
     }
     async planDestroy(format) {
         await this.__init();
         if (format === 'json')
             this.tfOutput = null;
-        this.tfOutput = await plan(this.projectPath, this.secrets, format, [
-            'plan',
-            '-destroy',
-        ]);
+        this.tfOutput = await plan(this.projectPath, this.secrets, format, ['plan', '-destroy'], this.stream);
     }
     async apply() {
         await this.__init();
-        this.tfOutput += await apply(this.projectPath, this.secrets);
+        this.tfOutput += await apply(this.projectPath, this.secrets, this.stream);
+        if (this.stream)
+            this.stream.end();
     }
     async destroy() {
         await this.__init();
-        this.tfOutput += await destroy(this.projectPath, this.secrets);
+        this.tfOutput += await destroy(this.projectPath, this.secrets, this.stream);
+        if (this.stream)
+            this.stream.end();
     }
     async output() {
         await this.__init();
@@ -313692,6 +314199,7 @@ var lib_ajv_default = /*#__PURE__*/__nccwpck_require__.n(lib_ajv);
 
 
 
+
 class TFProjectManagerRemote {
     constructor(ctx) {
         this.tfOutput = '';
@@ -313704,6 +314212,14 @@ class TFProjectManagerRemote {
     getOutput() {
         return this.tfOutput;
     }
+    setStreamCallbacks(fnData, fnEnd, reopen = true) {
+        if (reopen || !this.stream)
+            this.stream = new external_stream_.PassThrough();
+        this.stream.on('data', (data) => {
+            fnData(data.toString());
+        });
+        this.stream.on('end', fnEnd);
+    }
     async build() {
         external_fs_.rmSync(this.projectPath, { recursive: true, force: true });
         await this.__configGit();
@@ -313735,19 +314251,25 @@ insteadOf = https://github.com`);
     async plan(format) {
         await this.__init();
         if (format === 'json') {
-            this.tfOutput = await plan(this.projectPath, this.secrets, format);
+            this.tfOutput = await plan(this.projectPath, this.secrets, format, ['plan'], this.stream);
         }
         else {
-            this.tfOutput += await plan(this.projectPath, this.secrets, format);
+            this.tfOutput += await plan(this.projectPath, this.secrets, format, ['plan'], this.stream);
         }
+        if (this.stream)
+            this.stream.end();
     }
     async apply() {
         await this.__init();
-        this.tfOutput += await apply(this.projectPath, this.secrets);
+        this.tfOutput += await apply(this.projectPath, this.secrets, this.stream);
+        if (this.stream)
+            this.stream.end();
     }
     async destroy() {
         await this.__init();
-        this.tfOutput += await destroy(this.projectPath, this.secrets);
+        this.tfOutput += await destroy(this.projectPath, this.secrets, this.stream);
+        if (this.stream)
+            this.stream.end();
     }
     async planDestroy(format) {
         await this.__init();
@@ -313776,6 +314298,7 @@ insteadOf = https://github.com`);
 
 
 
+
 const terraform_provisioner_ajv = new (lib_ajv_default())();
 const terraform_provisioner_validate = terraform_provisioner_ajv.compile(terraform_provisioner_src_schema);
 function validateContext(context) {
@@ -313793,7 +314316,8 @@ async function run() {
     await execCommand(command, tfProject);
 }
 // Programatic API
-async function runTerraformProvisioner(context, command = 'init') {
+async function runTerraformProvisioner(context, command = 'init', streaming) {
+    terraform_provisioner_src_logger.info(`Running command ${command} on a ${context.type} project`);
     validateContext(context);
     let tfProject = {};
     if (context.type === 'Inline') {
@@ -313802,10 +314326,14 @@ async function runTerraformProvisioner(context, command = 'init') {
     else if (context.type === 'Remote') {
         tfProject = new TFProjectManagerRemote(context);
     }
+    if (streaming) {
+        tfProject.setStreamCallbacks(streaming.fnData, streaming.fnEnd);
+    }
     const output = await execCommand(command, tfProject);
     return output;
 }
 async function execCommand(command, tfProject) {
+    terraform_provisioner_src_logger.info(`Executing command ${command} on ${tfProject.projectPath}`);
     await tfProject.build();
     switch (command) {
         case 'init':
@@ -313914,6 +314442,52 @@ async function* errorPolicyCompatibility(syncPolicy, generalPolicy, item, op) {
     await tryPublishError(item, op, message);
 }
 
+;// CONCATENATED MODULE: ../operator/src/user-feedback-ops/tf-checkrun.ts
+
+async function TFCheckRun(cmd, item) {
+    const prInfo = tf_checkrun_extractPrInfo(item);
+    if (!prInfo.prNumber) {
+        throw new Error('TFCheckRun: prNumber not retrievable');
+    }
+    const checkRun = await github_0.feedback.createCheckRun(prInfo.org, prInfo.repo, tf_checkrun_helperCreateCheckRunName(cmd), {
+        //Number(pr_number),
+        pullNumber: Number(prInfo.prNumber),
+        includeCheckRunComment: true,
+        checkRunComment: `The TFWorkspace is being processed (cmd=${cmd}). Details: `,
+    });
+    checkRun.mdOptionsDetails({
+        quotes: 'terraform',
+    });
+    checkRun.update('Initiating', 'queued');
+    return {
+        fnData: (d) => {
+            checkRun.update(d.toString(), 'in_progress');
+        },
+        fnEnd: () => {
+            checkRun.close('OK', true);
+        },
+        fnOnError: (err) => {
+            checkRun.close('KO', false);
+        },
+    };
+}
+function tf_checkrun_helperCreateCheckRunName(cmd) {
+    return `TFWorkspace - ${cmd}`;
+}
+function tf_checkrun_extractPrInfo(item) {
+    const prInfo = item.metadata.annotations['firestartr.dev/last-state-pr'];
+    const prNumber = prInfo.split('#')[1];
+    if (!prNumber)
+        throw new Error('No PR number found in CR');
+    const org = prInfo.split('#')[0].split('/')[0];
+    if (!org)
+        throw new Error('No org found in CR');
+    const repo = prInfo.split('#')[0].split('/')[1];
+    if (!repo)
+        throw new Error('No repo found in CR');
+    return { prNumber, repo, org };
+}
+
 ;// CONCATENATED MODULE: ../operator/src/tfworkspaces/process-operation.ts
 
 
@@ -313924,6 +314498,7 @@ async function* errorPolicyCompatibility(syncPolicy, generalPolicy, item, op) {
 
 
 
+
 const TF_PROJECTS_PATH = '/tmp/tfworkspaces';
 function process_operation_processOperation(item, op, handler) {
     try {
@@ -313957,7 +314532,7 @@ function process_operation_processOperation(item, op, handler) {
         }
     }
     catch (e) {
-        src_logger.error('TERRAFORM_PROCESSOR_OP_ERROR', { metadata: { op, error: e } });
+        operator_src_logger.error(`The Terraform processor encountered an error during operation '${op}': '${e}'.`);
         throw e;
     }
 }
@@ -313990,9 +314565,7 @@ async function* doPlanJSONFormat(item, op, handler) {
             message: 'Planning process started',
         };
         const deps = await handler.resolveReferences();
-        src_logger.info('TERRAFORM_PROCESSOR_PLAN_ASSESS_DEPS', {
-            metadata: { item, deps },
-        });
+        operator_src_logger.info(`The Terraform processor is planning to assess dependencies for item '${item.kind}/${item.metadata.name}' with dependencies: '${deps}'.`);
         const context = buildProvisionerContext(item, deps);
         let planType = 'plan-json';
         if ('deletionTimestamp' in item.metadata) {
@@ -314055,9 +314628,7 @@ async function* doPlanJSONFormat(item, op, handler) {
     }
     catch (e) {
         console.error(e);
-        src_logger.error('TERRAFORM_PROCESSOR_PLAN_OBSERVE_ERROR', {
-            metadata: { item, error: e },
-        });
+        operator_src_logger.error(`The Terraform processor encountered an error while observing the plan for item '${item.kind}/${item.metadata.name}': '${e}'.`);
         yield {
             item,
             reason: op,
@@ -314143,9 +314714,7 @@ async function* process_operation_sync(item, op, handler, syncPolicy, generalPol
         message: 'Sync process started',
     };
     if (!syncPolicy) {
-        src_logger.debug('TERRAFORM_PROCESSOR_NO_SYNC_POLICY_ONLY_OBSERVE', {
-            metadata: { op, item },
-        });
+        operator_src_logger.debug(`The Terraform processor is only observing item '${item.kind}/${item.metadata.name}' because no sync policy was found for operation '${op}'.`);
         yield* doPlanJSONFormat(item, op, handler);
         return;
     }
@@ -314164,9 +314733,7 @@ async function* process_operation_sync(item, op, handler, syncPolicy, generalPol
                 break;
             }
             default: {
-                src_logger.debug('TERRAFORM_PROCESSOR_POLICY_NOT_SUPPORTED', {
-                    metadata: { syncPolicy, item },
-                });
+                operator_src_logger.debug(`The Terraform processor detected a sync policy '${syncPolicy}' for item '${item.kind}/${item.metadata.name}' that is not supported.`);
                 yield* doPlanJSONFormat(item, op, handler);
                 break;
             }
@@ -314291,6 +314858,7 @@ async function* process_operation_nothing(item, op, handler) {
  * @param handler -
  */
 async function* process_operation_doApply(item, op, handler) {
+    const checkRunCtl = await TFCheckRun('apply', item);
     try {
         yield {
             item,
@@ -314337,14 +314905,9 @@ async function* process_operation_doApply(item, op, handler) {
             message: 'Provisioning process started',
         };
         const deps = await handler.resolveReferences();
-        src_logger.info('TERRAFORM_PROCESSOR_APPLY_ASSESS_DEPS', {
-            metadata: { item, deps },
-        });
+        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);
-        if (item.metadata.annotations['firestartr.dev/last-state-pr'] || false) {
-            await addApplyCommitStatus(item, 'pending', catalog_common.generic.getPrLinkFromAnnotationValue(item.metadata.annotations['firestartr.dev/last-state-pr']), 'Performing apply operation...', `Terraform Apply ${item.metadata.name}`);
-        }
-        const applyOutput = await runTerraformProvisioner(context, 'apply');
+        const applyOutput = await runTerraformProvisioner(context, 'apply', checkRunCtl);
         await tryPublishApply(item, applyOutput, 'TFWorkspace');
         const terraformOutputJson = await runTerraformProvisioner(context, 'output');
         if (!terraformOutputJson) {
@@ -314376,17 +314939,13 @@ async function* process_operation_doApply(item, op, handler) {
             message: 'doApply',
         };
         await handler.writeTerraformOutputInTfResult(item, output);
-        if (item.metadata.annotations['firestartr.dev/last-state-pr'] || false) {
-            await addApplyCommitStatus(item, 'success', catalog_common.generic.getPrLinkFromAnnotationValue(item.metadata.annotations['firestartr.dev/last-state-pr']), 'Apply operation completed', `Terraform Apply ${item.metadata.name}`);
-        }
         handler.success();
     }
     catch (e) {
+        checkRunCtl.fnOnError(e);
         console.error(e);
         await tryPublishApply(item, e, 'TFWorkspace');
-        src_logger.error('TERRAFORM_PROCESSOR_APPLY_ERROR', {
-            metadata: { item, op, error: e },
-        });
+        operator_src_logger.error(`The Terraform processor encountered an error during operation '${op}' for item '${item.kind}/${item.metadata.name}': '${e}'.`);
         yield {
             item,
             reason: op,
@@ -314408,9 +314967,6 @@ async function* process_operation_doApply(item, op, handler) {
             status: 'False',
             message: JSON.stringify(e),
         };
-        if (item.metadata.annotations['firestartr.dev/last-state-pr'] || false) {
-            await addApplyCommitStatus(item, 'failure', catalog_common.generic.getPrLinkFromAnnotationValue(item.metadata.annotations['firestartr.dev/last-state-pr']), 'Apply operation failed', `Terraform Apply ${item.metadata.name}`);
-        }
         handler.error();
         if (e) {
             await handler.writeTerraformOutputInTfResult(item, e);
@@ -314715,30 +315271,22 @@ async function tryAcquireOrRenewLease(namespace, leaseDurationSeconds) {
     const name = 'firestartr-lease';
     const currentPod = await getCurrentPod(namespace);
     try {
-        src_logger.debug('LEADER_ELECTION_TRYING_ACQUIRE_LEASE', {
-            metadata: { name, namespace },
-        });
+        operator_src_logger.debug(`Attempting to acquire the leader election lease for '${name}' in namespace '${namespace}'.`);
         const lease = await k8sApi.readNamespacedLease(name, namespace);
         const weAreTheLeader = lease.body.metadata.ownerReferences[0].uid === currentPod.metadata.uid;
         if (!weAreTheLeader) {
-            src_logger.debug('LEADER_ELECTION_LEASE_ACQUIRED_BY_ANOTHER_POD', {
-                metadata: { name, namespace },
-            });
+            operator_src_logger.debug(`Another pod has acquired the leader election lease for '${name}' in namespace '${namespace}'.`);
             throw new LeaseAcquisitionError('Lease already acquired by another pod');
         }
         lease.body.spec.acquireTime = new client_node_dist.V1MicroTime();
         lease.body.spec.renewTime = new client_node_dist.V1MicroTime();
         lease.body.spec.leaseDurationSeconds = 30;
-        src_logger.debug('LEADER_ELECTION_LEASE_RENEWING', {
-            metadata: { name, namespace },
-        });
+        operator_src_logger.debug(`Renewing the leader election lease for '${name}' in namespace '${namespace}'.`);
         await k8sApi.replaceNamespacedLease(name, namespace, lease.body);
     }
     catch (err) {
         if (err.response && err.response.statusCode === 404) {
-            src_logger.debug('LEADER_ELECTION_LEASE_NOT_FOUND_CREATING', {
-                metadata: { name, namespace },
-            });
+            operator_src_logger.debug(`The leader election lease for '${name}' in namespace '${namespace}' was not found. Creating a new one.`);
             const lease = {
                 apiVersion: 'coordination.k8s.io/v1',
                 kind: 'Lease',
@@ -314761,16 +315309,12 @@ async function tryAcquireOrRenewLease(namespace, leaseDurationSeconds) {
                 },
             };
             await k8sApi.createNamespacedLease(namespace, lease);
-            src_logger.debug('LEADER_ELECTION_LEASE_CREATED', {
-                metadata: { name, namespace },
-            });
+            operator_src_logger.debug(`A new leader election lease has been created for '${name}' in namespace '${namespace}'.`);
         }
         else {
             if (err.response)
                 console.log(err.response);
-            src_logger.debug('LEADER_ELECTION_LEASE_RENEWAL_ERROR', {
-                metadata: { name, namespace, error: err },
-            });
+            operator_src_logger.debug(`An error occurred while renewing the leader election lease for '${name}' in namespace '${namespace}': '${err}'.`);
             throw err;
         }
     }
@@ -314781,9 +315325,7 @@ async function tryAcquireOrRenewLease(namespace, leaseDurationSeconds) {
 async function acquireLease(namespace, cb, interval = 10000) {
     try {
         await tryAcquireOrRenewLease(namespace, interval / 1000);
-        src_logger.debug('LEADER_ELECTION_LEASE_ACQUIRED_EXEC_CALLBACK', {
-            metadata: { namespace },
-        });
+        operator_src_logger.debug(`Successfully acquired the leader election lease in namespace '${namespace}'. Executing the callback.`);
         cb();
     }
     catch (err) {
@@ -314791,9 +315333,7 @@ async function acquireLease(namespace, cb, interval = 10000) {
         if (err instanceof LeaseAcquisitionError) {
             console.error(`Failed to acquire Lease, retrying in ${interval / 1000} seconds`);
         }
-        src_logger.silly('LEADER_ELECTION_LEASE_ACQUIRED_FAILED_RETRY', {
-            metadata: { retryIn: interval / 1000 },
-        });
+        operator_src_logger.silly(`Failed to acquire the leader election lease; will retry in '${interval / 1000}' seconds.`);
         await setTimeout(() => acquireLease(namespace, cb), interval);
     }
 }
@@ -314822,7 +315362,7 @@ function processOperationPlan(item, op, handler) {
         }
     }
     catch (e) {
-        src_logger.error('TFWORKSPACE_PROCESSOR_PLAN_ERROR', {
+        operator_src_logger.error('TFWORKSPACE_PROCESSOR_PLAN_ERROR', {
             metadata: { item, error: e, op },
         });
         throw e;
@@ -314873,7 +315413,7 @@ async function* doPlanPlainTextFormat(item, op, handler, action) {
             message: 'Planning process started',
         };
         const deps = await handler.resolveReferences();
-        src_logger.info('TFWORKSPACE_PROCESSOR_PLAN_ASSESS_DEPS', {
+        operator_src_logger.info('TFWORKSPACE_PROCESSOR_PLAN_ASSESS_DEPS', {
             metadata: { item, deps },
         });
         const context = processOperationPlan_buildProvisionerContext(item, deps);
@@ -314909,7 +315449,7 @@ async function* doPlanPlainTextFormat(item, op, handler, action) {
     }
     catch (e) {
         await processOperationPlan_publishPlan(item, JSON.stringify(e));
-        src_logger.error('TFWORKSPACE_PROCESSOR_PLAN_OBSERVING_ERROR', {
+        operator_src_logger.error('TFWORKSPACE_PROCESSOR_PLAN_OBSERVING_ERROR', {
             metadata: { item, error: e },
         });
         yield {
@@ -314967,7 +315507,7 @@ async function* processOperationPlan_doPlanJSONFormat(item, op, handler, action)
             message: 'Planning process started',
         };
         const deps = await handler.resolveReferences();
-        src_logger.info('TFWORKSPACE_PROCESSOR_PLAN_DO_PLAN_ASSESS_DEPS', {
+        operator_src_logger.info('TFWORKSPACE_PROCESSOR_PLAN_DO_PLAN_ASSESS_DEPS', {
             metadata: { item, deps },
         });
         const context = processOperationPlan_buildProvisionerContext(item, deps);
@@ -315027,7 +315567,7 @@ async function* processOperationPlan_doPlanJSONFormat(item, op, handler, action)
     }
     catch (e) {
         console.error(e);
-        src_logger.error('TFWORKSPACE_PROCESSOR_PLAN_DO_PLAN_ERROR', {
+        operator_src_logger.error('TFWORKSPACE_PROCESSOR_PLAN_DO_PLAN_ERROR', {
             metadata: { item, error: e },
         });
         yield {
@@ -315394,42 +315934,30 @@ async function ctx_buildContext(claim, namespace, command) {
     let cr = null;
     let deps = null;
     compute['resolveDeps'] = async () => {
-        src_logger.debug('TFWORKSPACE_RESOLVE_DEPS_FOR_CLAIM', {
-            metadata: { name: claim.name },
-        });
+        operator_src_logger.debug(`The Terraform workspace is resolving dependencies for the claim '${claim.name}'.`);
         // First, we bring the previous CR, if any, to get the tfStateKey
-        src_logger.debug('TFWORKSPACE_RESOLVE_GET_PREVIOUS_CR', {
-            metadata: { name: claim.name },
-        });
+        operator_src_logger.debug(`The Terraform workspace is resolving and getting the previous custom resource for claim '${claim.name}'.`);
         previousCR = await getCRfromClaimRef(claim.kind, claim.name, namespace);
         let tfStateKey = null;
         if (previousCR) {
-            src_logger.debug('TFWORKSPACE_RESOLVE_PREVIOUS_CR_FOUND', {
-                metadata: { name: claim.name },
-            });
+            operator_src_logger.debug(`The Terraform workspace found a previous custom resource for claim '${claim.name}'.`);
             tfStateKey = previousCR.spec.firestartr.tfStateKey;
         }
         else
-            src_logger.debug('TFWORKSPACE_RESOLVE_PREVIOUS_CR_NOT_FOUND', {
-                metadata: { name: claim.name },
-            });
+            operator_src_logger.debug(`The Terraform workspace did not find a previous custom resource for claim '${claim.name}'.`);
         // Then we render the claim passing a function to resolve the refs in the k8s API
-        src_logger.debug('TFWORKSPACE_RESOLVE_START_RENDERING', {
-            metadata: { name: claim.name },
-        });
+        operator_src_logger.debug(`The Terraform workspace is starting the rendering process for claim '${claim.name}'.`);
         cr = await cdk8s_renderer.renderTfWorkspace(claim, tfStateKey, getTFWorkspaceRefs, namespace);
         cr['metadata']['namespace'] = namespace;
-        src_logger.debug('TFWORKSPACE_RESOLVE_CR_RENDERED', { metadata: { cr } });
+        operator_src_logger.debug(`The Terraform workspace has finished rendering the custom resource '${cr.kind}/${cr.metadata.name}' in namespace '${cr.metadata.namespace}'.`);
         // Finally, we resolve the deps in the rendered CR
         deps = await resolve(cr, getItemByItemPath, getSecret, namespace);
-        src_logger.debug('TFWORKSPACE_RESOLVE_DEPS_RESOLVED', {
-            metadata: { name: claim.name },
-        });
+        operator_src_logger.debug(`The Terraform workspace has finished resolving all dependencies for claim '${claim.name}'.`);
     };
     compute['dryRunExec'] = async () => {
         // We assume that if there is no previous CR, we are creating a new one
         // This will be preceeded by the resolveDeps function
-        src_logger.debug('TFWORKSPACE_DRY_RUN_VALIDATING_CR', { metadata: { cr } });
+        operator_src_logger.debug(`The Terraform workspace is dry-running the validation for custom resource '${cr.kind}/${cr.metadata.name}' in namespace '${cr.metadata.namespace}'.`);
         if (!previousCR) {
             await createDryRun(cr, namespace);
         }
@@ -315437,17 +315965,15 @@ async function ctx_buildContext(claim, namespace, command) {
             cr.metadata.resourceVersion = previousCR.metadata.resourceVersion;
             await updateDryRun(cr, namespace);
         }
-        src_logger.debug('TFWORKSPACE_DRY_RUN_VALIDATED_CR', { metadata: { cr } });
+        operator_src_logger.debug(`The Terraform workspace has finished validating the custom resource '${cr.kind}/${cr.metadata.name}' in namespace '${cr.metadata.namespace}'.`);
     };
     compute['runProvision'] = async () => {
-        src_logger.debug('TFWORKSPACE_RUN_PROVISION_INIT_TERRAFORM', {
+        operator_src_logger.debug('TFWORKSPACE_RUN_PROVISION_INIT_TERRAFORM', {
             metadata: { cr, command },
         });
         const data = await buildProvisionerContext(cr, deps);
         const result = await runTerraformProvisioner(data, command);
-        src_logger.debug('TFWORKSPACE_RUN_PROVISION_FINISHED_TERRAFORM', {
-            metadata: { cr, command },
-        });
+        operator_src_logger.debug(`The Terraform workspace has finished the '${command}' command for provisioning custom resource '${cr.kind}/${cr.metadata.name}' in namespace '${cr.metadata.namespace}'.`);
         return result;
     };
     return new Ctx({}, compute);
@@ -315600,27 +316126,28 @@ var sdk_metrics_build_src = __nccwpck_require__(84016);
 ;// CONCATENATED MODULE: ../operator/src/metrics/CRStates.ts
 
 
+
 const INTERVAL_IN_SEGS = 60;
 class CRStateMetrics {
     constructor(kind, namespace, meter) {
         this.kind = kind;
-        this.provisionedGauge = meter.createGauge(`firestartr_${this.kind}_provisioned_total`, {
-            description: `Total number of ${this.kind} in PROVISIONED state`,
+        this.provisionedGauge = meter.createGauge('firestartr_provisioned_total', {
+            description: 'Total number of CRs in PROVISIONED state',
         });
-        this.provisioningGauge = meter.createGauge(`firestartr_${this.kind}_provisioning_total`, {
-            description: `Total number of ${this.kind} in PROVISIONING state`,
+        this.provisioningGauge = meter.createGauge('firestartr_provisioning_total', {
+            description: 'Total number of CRs in PROVISIONING state',
         });
-        this.outOfSyncGauge = meter.createGauge(`firestartr_${this.kind}_out_of_sync_total`, {
-            description: `Total number of ${this.kind} in OUT_OF_SYNC state`,
+        this.outOfSyncGauge = meter.createGauge('firestartr_out_of_sync_total', {
+            description: 'Total number of CRs in OUT_OF_SYNC state',
         });
-        this.errorGauge = meter.createGauge(`firestartr_${this.kind}_error_total`, {
-            description: `Total number of ${this.kind} in ERROR state`,
+        this.errorGauge = meter.createGauge('firestartr_error_total', {
+            description: 'Total number of CRs in ERROR state',
         });
-        this.planningGauge = meter.createGauge(`firestartr_${this.kind}_planning_total`, {
-            description: `Total number of ${this.kind} in PLANNING state`,
+        this.planningGauge = meter.createGauge('firestartr_planning_total', {
+            description: 'Total number of CRs in PLANNING state',
         });
-        this.deletedGauge = meter.createGauge(`firestartr_${this.kind}_deleted_total`, {
-            description: `Total number of ${this.kind} in DELETED state`,
+        this.deletedGauge = meter.createGauge('firestartr_deleted_total', {
+            description: 'Total number of CRs in DELETED state',
         });
         this.namespace = namespace;
     }
@@ -315677,19 +316204,33 @@ class CRStateMetrics {
             }
             this.provisionedGauge.record(provisionedCount, {
                 namespace: this.namespace,
+                kind: this.kind,
             });
             this.provisioningGauge.record(provisioningCount, {
                 namespace: this.namespace,
+                kind: this.kind,
+            });
+            this.planningGauge.record(planningCount, {
+                namespace: this.namespace,
+                kind: this.kind,
+            });
+            this.deletedGauge.record(deletedCount, {
+                namespace: this.namespace,
+                kind: this.kind,
+            });
+            this.outOfSyncGauge.record(outOfSyncCount, {
+                namespace: this.namespace,
+                kind: this.kind,
+            });
+            this.errorGauge.record(errorCount, {
+                namespace: this.namespace,
+                kind: this.kind,
             });
-            this.planningGauge.record(planningCount, { namespace: this.namespace });
-            this.deletedGauge.record(deletedCount, { namespace: this.namespace });
-            this.outOfSyncGauge.record(outOfSyncCount, { namespace: this.namespace });
-            this.errorGauge.record(errorCount, { namespace: this.namespace });
         }
         catch (err) {
-            console.log(err);
+            console.log(`CRStateMetrics: update ${err}`);
             this.onUpdate = false;
-            throw new Error(`CRStateMetrics: update ${err}`);
+            operator_src_logger.error('CR_METRICS_UPDATE', { error: err });
         }
         this.onUpdate = false;
     }
@@ -315783,7 +316324,7 @@ async function startCRStates(meter, kindList, namespace) {
 
 const deploymentName = catalog_common.environment.getFromEnvironment(catalog_common.types.envVars.operatorDeploymentName) || 'firestartr-firestartr-controller';
 const DEFAULT_OPERATOR_DEPLOY = (/* unused pure expression or super */ null && (deploymentName));
-async function tfPlanner(claimFilePath, claim, namespace, debug, jobTtl, cmd = 'plan') {
+async function tfPlanner(claimFilePath, claim, namespace, debug, jobTtl = 300, cmd = 'plan') {
     const { kc } = await getConnection();
     const k8sApi = kc.makeApiClient(client.AppsV1Api);
     const batchV1Api = kc.makeApiClient(client.BatchV1Api);
@@ -315803,10 +316344,12 @@ async function tfPlanner(claimFilePath, claim, namespace, debug, jobTtl, cmd = '
         ? '/library/scripts/run.sh'
         : '/library/run.sh';
     job.spec = new client.V1JobSpec();
-    if (jobTtl)
-        job.spec.ttlSecondsAfterFinished = jobTtl;
+    job.spec.ttlSecondsAfterFinished = jobTtl;
     job.spec.template = controllerDeploy.body.spec
         .template;
+    // set activeDeadlineSeconds to force terminate jobs that exceed this time
+    // see https://kubernetes.io/docs/concepts/workloads/controllers/job/#job-termination-and-cleanup
+    job.spec.activeDeadlineSeconds = 3600;
     job.spec.template.spec.containers[0].command = [
         'sh',
         '-c',
@@ -315818,9 +316361,12 @@ async function tfPlanner(claimFilePath, claim, namespace, debug, jobTtl, cmd = '
     }
     job.spec.template.spec.restartPolicy = 'Never';
     job.metadata = metadata;
+    // we exclude logs to be sent to datadog
+    job.spec.template.metadata.annotations = {
+        'ad.datadoghq.com/logs_exclude': 'true',
+    };
     await batchV1Api.createNamespacedJob(namespace, job);
     await copyClaimAndGetLogs(namespace, job.metadata.name, claimFilePath);
-    await batchV1Api.deleteNamespacedJob(job.metadata.name, namespace);
 }
 async function copyClaimAndGetLogs(namespace, jobName, sourcePath) {
     const { kc } = await getConnection();
@@ -315974,7 +316520,7 @@ function runOperator(opts) {
         importModeActive = importMode;
     if (importModeSkipPlan)
         importModeSkipPlanActive = importModeSkipPlan;
-    src_logger.info('START_OPERATOR', { ...opts });
+    operator_src_logger.info(`started the operator with options ${JSON.stringify(opts)}`);
     const run = ignoreLease
         ? (_namespace, cb) => cb()
         : acquireLease;
@@ -315994,7 +316540,7 @@ function runOperator(opts) {
                     .catch((e) => {
                     console.log('exit catch kind', kind);
                     console.error(e);
-                    src_logger.error('CRASHED', { kind, error: e });
+                    operator_src_logger.error('CRASHED', { kind, error: e });
                 })
                     .finally(() => {
                     console.log('kind', kind);
@@ -316026,7 +316572,7 @@ function getProvisionImplementation(plural) {
     }
     if (!implementation)
         throw new Error(`No implementation found for ${plural}`);
-    src_logger.info('GOT_PROVISION_IMPL', { kind: plural });
+    operator_src_logger.info(`Retrieved the provision implementation for the kind '${plural}'`);
     return implementation;
 }