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

package/build/index.js

@@ -357045,6 +357045,7 @@ class FirestartrAllClaim {
 
 
 
+
 class RefValuesNormalizer extends Normalizer {
     constructor() {
         super(...arguments);
@@ -357084,6 +357085,14 @@ providerValues, resolveRef, references = new Map()) {
     for (const key in providerValues) {
         values[key] = await interpolateObject(providerValues[key], references, resolveRef);
     }
+    let secretRefCount = 0;
+    for (const key in providerValues) {
+        if (isRepoSecretRef(providerValues[key])) {
+            values[key] = await interpolateSecretClaimRef(providerValues[key], references, 
+            // closure to increase the refCount and avoid collision
+            () => secretRefCount++);
+        }
+    }
     return { values, references: Array.from(updatedReferences.values()) };
 }
 async function interpolateObject(toInterpolate, references, resolveRef) {
@@ -357153,6 +357162,40 @@ async function replaceReferencesValues(contents, references, resolveRef) {
     }
     return replacedContent;
 }
+async function interpolateSecretClaimRef(secretClaimRef, references, getSecretRefCountF) {
+    const extractedSecretClaimRef = {
+        ...extractRepoSecretRef(secretClaimRef),
+        // force the kind to ALWAYS be a Secret
+        kind: 'Secret',
+    };
+    // has already been visited
+    const alreadyPresentKey = findSecretKey(extractedSecretClaimRef, references);
+    if (alreadyPresentKey)
+        return alreadyPresentKey;
+    // new reference we have to build it
+    const secretClaimRefInternalKey = `secret-ref-${getSecretRefCountF()}`;
+    // we set the secret value
+    references.set(secretClaimRefInternalKey, {
+        name: secretClaimRefInternalKey,
+        ref: extractedSecretClaimRef,
+    });
+    return secretClaimRefInternalKey;
+}
+function findSecretKey(secretClaimRef, references) {
+    const entry = Array.from(references.entries()).find(([, value]) => {
+        // Destructure the entry to easily access the value.
+        // Check if the value is an object and matches all properties.
+        return (typeof value === 'object' &&
+            value !== null &&
+            value.ref !== null &&
+            typeof value.ref === 'object' &&
+            value.ref.kind === secretClaimRef.kind &&
+            value.ref.name === secretClaimRef.name &&
+            value.ref.key === secretClaimRef.key);
+    });
+    // If a matching entry was found, return its key (the first element of the entry array).
+    return entry ? entry[0] : undefined;
+}
 
 ;// CONCATENATED MODULE: ../cdk8s_renderer/src/normalizers/RevisionNormalizer.ts
 
@@ -357284,14 +357327,20 @@ const kindMap = {
     secret: 'SecretsClaim',
     domain: 'DomainClaim',
 };
+// this function is intended to search for refs of the same kind
+// it is used to search for circular references (i.e. a reference to oneself)
+// to extract all type of references use extractAllRefs
 function extractRefs(renderClaims, kind) {
     const result = {};
     for (const key in renderClaims) {
         const claim = renderClaims[key].claim;
         let refs = [];
+        // for workspaces
+        let [tfWorkspaceRefs, secretsRefs] = [[], []];
         switch (kind) {
             case 'TFWorkspaceClaim':
-                refs = getTfWorkspacesRefs(claim.providers.terraform.values);
+                [tfWorkspaceRefs, secretsRefs] = getTfWorkspacesRefs(claim.providers.terraform.values);
+                refs = [...tfWorkspaceRefs];
                 break;
             case 'GroupClaim':
                 /**
@@ -357315,11 +357364,13 @@ function extractAllRefs(claimData) {
     refs.push(...extractVirtualRefs(parsedClaim));
     switch (parsedClaim.kind) {
         case 'TFWorkspaceClaim': {
-            const tfWorkspaceRefs = getTfWorkspacesRefs(parsedClaim.providers.terraform.values);
+            const [tfWorkspaceRefs, secretRefs] = getTfWorkspacesRefs(parsedClaim.providers.terraform.values);
             tfWorkspaceRefs.forEach((ref, idx, arr) => {
                 arr[idx] = `TFWorkspaceClaim-${ref}`;
             });
+            cdk8s_renderer_src_logger.debug(`Obtained the following secret refs for ${parsedClaim.kind}/${parsedClaim.name}: ${JSON.stringify(secretRefs)}`);
             refs.push(...tfWorkspaceRefs);
+            refs.push(...secretRefs);
             break;
         }
         case 'GroupClaim': {
@@ -357364,22 +357415,28 @@ function getGroupParentRef(parent, references = []) {
     }
     return references;
 }
-function getTfWorkspacesRefs(values, references = []) {
+function getTfWorkspacesRefs(values, references = [], secretsRefs = []) {
     const regex = catalog_common.types.regex.TFWorkspaceRefRegex;
     for (const key in values) {
         switch (typeof values[key]) {
             case 'object':
-                getTfWorkspacesRefs(values[key], references);
+                getTfWorkspacesRefs(values[key], references, secretsRefs);
                 break;
             case 'string':
+                // Extract all implicit refs
                 for (const match of values[key].matchAll(regex)) {
                     const [_, claimName] = match;
                     references.push(claimName);
                 }
+                // extract a secretsclaim ref
+                if (isRepoSecretRef(values[key])) {
+                    const secretRef = extractRepoSecretRef(values[key]);
+                    secretsRefs.push(`SecretsClaim-${secretRef.name}`);
+                }
                 break;
         }
     }
-    return references;
+    return [references, secretsRefs];
 }
 function getComponentVarsAndSecretsRefs(parsedClaim) {
     const refs = {};
@@ -359560,7 +359617,6 @@ var ajv_default = /*#__PURE__*/__nccwpck_require__.n(dist_ajv);
 
 
 
-
 function validate_validate(featurePath) {
     __validateDirStructure(featurePath);
     const configData = __validateFeatureConfig(featurePath);
@@ -359575,17 +359631,6 @@ function __validateDirStructure(featurePath) {
     if (!isFile(external_path_.join(featurePath, 'config.yaml'))) {
         throw `Feature: ${featurePath}/config.yaml not found or not a file`;
     }
-    if (!isDirectory(external_path_.join(featurePath, 'templates/docs'))) {
-        throw `Feature: ${featurePath}templates/docs not a directory`;
-    }
-    if (!__validateDocsHasReadmes(featurePath)) {
-        throw `Feature: ${featurePath}: should have at least one .md file in the templates/docs`;
-    }
-}
-function __validateDocsHasReadmes(featurePath) {
-    const dirEntries = external_fs_default().readdirSync(external_path_.join(featurePath, 'templates/docs'));
-    return (dirEntries.some((entryFile) => !isDirectory(external_path_.join(featurePath, '/templates/docs', entryFile)) &&
-        entryFile.endsWith('.md')) !== undefined);
 }
 function __validateFeatureConfig(featurePath) {
     try {
@@ -360641,7 +360686,6 @@ function buildExpectedOutput(config, renderDir) {
         localPath: external_node_path_.join(renderDir, f.dest),
         repoPath: f.dest,
         userManaged: f.user_managed,
-        targetBranch: f.target_branch ?? '',
     }));
     return {
         files,
@@ -363464,6 +363508,8 @@ var FirestartrTerraformWorkspaceSpecReferencesRefKind;
     FirestartrTerraformWorkspaceSpecReferencesRefKind["FIRESTARTR_TERRAFORM_WORKSPACE"] = "FirestartrTerraformWorkspace";
     /** ExternalSecret */
     FirestartrTerraformWorkspaceSpecReferencesRefKind["EXTERNAL_SECRET"] = "ExternalSecret";
+    /** Secret */
+    FirestartrTerraformWorkspaceSpecReferencesRefKind["SECRET"] = "Secret";
 })(FirestartrTerraformWorkspaceSpecReferencesRefKind || (FirestartrTerraformWorkspaceSpecReferencesRefKind = {}));
 /**
  * @schema FirestartrTerraformWorkspaceSpecContextBackendRefKind
@@ -367733,12 +367779,19 @@ function updateConditionByType(conditionList, type, newCondition) {
     return conditionList;
 }
 
+;// CONCATENATED MODULE: ../operator/src/utils/operationErrorMessages.ts
+const APPLY_DEFAULT_ERROR_MESSAGE = 'An error occurred while executing the Terraform apply operation.';
+const DESTROY_DEFAULT_ERROR_MESSAGE = 'An error occurred while executing the Terraform destroy operation.';
+const PLAN_DEFAULT_ERROR_MESSAGE = 'An error occurred while executing the Terraform plan operation.';
+const SYNC_DEFAULT_ERROR_MESSAGE = 'An error occurred while executing the Sync operation.';
+
 ;// CONCATENATED MODULE: ../operator/src/syncCtl.ts
 // Machinery for syncing
 
 
 
 
+
 const DEFAULT_REVISION_TIME = '1m';
 async function createWatcherForItem(itemPath, itemCR) {
     const item = itemCR ?? (await getItemByItemPath(itemPath));
@@ -367801,7 +367854,7 @@ async function getSyncStatus(itemPath, itemCR) {
             : (await getSyncSpecs(itemPath, item)).schedule
                 ? 'Scheduled'
                 : 'Period';
-        return {
+        const syncStatus = {
             itemPath,
             syncMode: mode,
             conditions: [syncCondition],
@@ -367809,6 +367862,11 @@ async function getSyncStatus(itemPath, itemCR) {
             nextTimeoutInMS: isLapsed ? -1 : nextSyncDate.getTime() - Date.now(),
             intervalLapsed: isLapsed,
         };
+        if (syncCondition) {
+            syncStatus.hasSyncFailed =
+                syncCondition.message === SYNC_DEFAULT_ERROR_MESSAGE;
+        }
+        return syncStatus;
     }
 }
 async function setSyncStatus(itemPath, reason, status, message) {
@@ -368457,6 +368515,15 @@ function enqueue(pluralKind, workItem, queue, compute, syncCtl, retryCtl) {
             yield transition;
         }
         if (needsUpdateSyncConditions) {
+            if (operation === OperationType.SYNC) {
+                // let's check if the process has not failed
+                const syncStatus = await getSyncStatus(workItem.handler.itemPath());
+                if (syncStatus.hasSyncFailed) {
+                    // we do not update sync because we are not going to trigger
+                    // a RETRY operation if the sync has failed
+                    return;
+                }
+            }
             await setSyncStatus(workItem.handler.itemPath(), operation, operation === OperationType.SYNC ? 'True' : 'False', 'Sync process finished');
             void syncCtl.updateItem(informer_itemPath(pluralKind, item));
         }
@@ -369477,9 +369544,7 @@ function provisionFeatureFiles(scope, feature) {
                 ? { ignoreChanges: ['content'] }
                 : {};
             const repoConfig = {
-                branch: file.targetBranch.length === 0
-                    ? defaultBranchName
-                    : file.targetBranch,
+                branch: file.targetBranch || defaultBranchName,
                 commitMessage: `feat: ${feature.spec.type} ${feature.spec.version}`,
                 content: cdktf_lib.Fn.base64decode(file.content),
                 file: file.path,
@@ -371177,11 +371242,6 @@ function helperCreateCheckRunName(cmd, item) {
     return `${item.kind} - ${cmd}`;
 }
 
-;// CONCATENATED MODULE: ../operator/src/utils/operationErrorMessages.ts
-const APPLY_DEFAULT_ERROR_MESSAGE = 'An error occurred while executing the Terraform apply operation.';
-const DESTROY_DEFAULT_ERROR_MESSAGE = 'An error occurred while executing the Terraform destroy operation.';
-const PLAN_DEFAULT_ERROR_MESSAGE = 'An error occurred while executing the Terraform plan operation.';
-
 ;// CONCATENATED MODULE: ../operator/cdktf.ts
 
 
@@ -371954,6 +372014,8 @@ ${this.mainBlock}
 }
 
 ;// CONCATENATED MODULE: ../terraform_provisioner/src/resolutor/resolver.ts
+
+const REG_IS_CLAIM_SECRET_REF = new RegExp(/^secret-ref-\d+$/);
 function resolveString(value, refs) {
     const regex = new RegExp(/(\$\{\{\s*references\.[\w\-.]+\s*\}\})/);
     if (hasRefs(value, regex) > 0) {
@@ -372007,6 +372069,18 @@ function getRefNameFromKey(key) {
     // name is in the first matching group
     return match[1];
 }
+function resolveClaimSecret(value, refs) {
+    if (typeof value === 'string' && REG_IS_CLAIM_SECRET_REF.test(value)) {
+        if (!Object.prototype.hasOwnProperty.call(refs, value)) {
+            terraform_provisioner_src_logger.error(`SecretsClaim ref ${value} is not present on references`);
+            throw new Error(`SecretsClaim ref ${value} is not present on references`);
+        }
+        return refs[value];
+    }
+    else {
+        return value;
+    }
+}
 function resolveRef(key, references, wantsInterpolation = false) {
     const refName = getRefNameFromKey(key);
     // check if key exists
@@ -372055,6 +372129,9 @@ function walkList(list, resolveScalar) {
 function resolveValues(values, refs) {
     return walker_walk(values, (value) => resolveScalar(value, refs));
 }
+function resolveClaimSecrets(values, refs) {
+    return walker_walk(values, (value) => resolveClaimSecret(value, refs));
+}
 
 ;// CONCATENATED MODULE: ../terraform_provisioner/src/writer_tfvars_json.ts
 
@@ -372066,7 +372143,9 @@ class WriterTfVarsJson extends writer {
         this.references = references;
     }
     __replaceReferences(values, references) {
-        return resolveValues(values, references);
+        values = resolveValues(values, references);
+        values = resolveClaimSecrets(values, references);
+        return values;
     }
     __resolveDeps() {
         const replaced = this.__replaceReferences(this.values, this.references);
@@ -372622,7 +372701,7 @@ async function* process_operation_observe(item, op, handler) {
         yield transition;
     }
 }
-async function* doPlanJSONFormat(item, op, handler) {
+async function* doPlanJSONFormat(item, op, handler, setResult = function (_r) { }) {
     let error = false;
     try {
         yield {
@@ -372723,34 +372802,83 @@ async function* doPlanJSONFormat(item, op, handler) {
     }
     finally {
         if (error) {
-            yield {
-                item,
-                reason: op,
-                type: 'PROVISIONED',
-                status: 'False',
-                message: PLAN_DEFAULT_ERROR_MESSAGE,
-            };
-            yield {
-                item,
-                reason: op,
-                type: 'PLANNING',
-                status: 'False',
-                message: PLAN_DEFAULT_ERROR_MESSAGE,
-            };
-            yield {
-                item,
-                reason: op,
-                type: 'OUT_OF_SYNC',
-                status: 'False',
-                message: PLAN_DEFAULT_ERROR_MESSAGE,
-            };
-            yield {
-                item,
-                reason: op,
-                type: 'ERROR',
-                status: 'True',
-                message: PLAN_DEFAULT_ERROR_MESSAGE,
-            };
+            if (op === OperationType.SYNC) {
+                // if there is an error on a sync we never put the state on error
+                // it would be problematic because the RETRY op kicks in
+                if (error) {
+                    yield {
+                        item,
+                        reason: op,
+                        type: 'SYNCHRONIZED',
+                        status: 'True',
+                        message: SYNC_DEFAULT_ERROR_MESSAGE,
+                    };
+                    yield {
+                        item,
+                        reason: op,
+                        type: 'PROVISIONED',
+                        status: 'True',
+                        message: 'doPlanJSONFormat',
+                    };
+                    yield {
+                        item,
+                        reason: op,
+                        type: 'PLANNING',
+                        status: 'False',
+                        message: 'doPlanJSONFormat',
+                    };
+                    yield {
+                        item,
+                        reason: op,
+                        type: 'OUT_OF_SYNC',
+                        status: 'False',
+                        message: 'doPlanJSONFormat',
+                    };
+                    yield {
+                        item,
+                        reason: op,
+                        type: 'ERROR',
+                        status: 'False',
+                        message: 'doPlanJSONFormat',
+                    };
+                }
+                setResult('SYNC_ERROR_PLAN');
+            }
+            else {
+                yield {
+                    item,
+                    reason: op,
+                    type: 'PROVISIONED',
+                    status: 'False',
+                    message: PLAN_DEFAULT_ERROR_MESSAGE,
+                };
+                yield {
+                    item,
+                    reason: op,
+                    type: 'PLANNING',
+                    status: 'False',
+                    message: PLAN_DEFAULT_ERROR_MESSAGE,
+                };
+                yield {
+                    item,
+                    reason: op,
+                    type: 'OUT_OF_SYNC',
+                    status: 'False',
+                    message: PLAN_DEFAULT_ERROR_MESSAGE,
+                };
+                yield {
+                    item,
+                    reason: op,
+                    type: 'ERROR',
+                    status: 'True',
+                    message: PLAN_DEFAULT_ERROR_MESSAGE,
+                };
+            }
+        }
+        else {
+            if (op === OperationType.SYNC) {
+                setResult('SYNC_SUCCESS');
+            }
         }
     }
 }
@@ -372793,6 +372921,7 @@ function isDestroyRetry(item) {
     return false;
 }
 async function* process_operation_sync(item, op, handler, syncPolicy, generalPolicy) {
+    let doResult = '';
     if (!syncPolicy) {
         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);
@@ -372809,23 +372938,30 @@ async function* process_operation_sync(item, op, handler, syncPolicy, generalPol
                 break;
             }
             case 'observe': {
-                yield* doPlanJSONFormat(item, op, handler);
+                yield* doPlanJSONFormat(item, op, handler, (result) => {
+                    doResult = result;
+                });
                 break;
             }
             default: {
                 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);
+                yield* doPlanJSONFormat(item, op, handler, (result) => {
+                    doResult = result;
+                });
                 break;
             }
         }
     }
-    yield {
-        item,
-        reason: op,
-        type: 'SYNCHRONIZED',
-        status: 'True',
-        message: 'Sync process finished',
-    };
+    operator_src_logger.debug(`doResult is ${doResult}`);
+    if (doResult === 'SYNC_SUCCESS') {
+        yield {
+            item,
+            reason: op,
+            type: 'SYNCHRONIZED',
+            status: 'True',
+            message: 'Sync process finished',
+        };
+    }
 }
 async function* process_operation_markedToDeletion(item, op, handler) {
     let error = false;
@@ -373228,6 +373364,9 @@ function resolveReferences(item, deps) {
         // if(!process.env.TONISILLO) process.exit(1)
         for (const iRef of itemReferences) {
             const ref = deps[`${iRef.ref.kind}-${iRef.ref.name}`];
+            if (iRef.ref.kind === 'Secret') {
+                ref.secret = ref.cr;
+            }
             if (!ref) {
                 throw new Error(`Reference ${iRef.ref.kind}-${iRef.ref.name} not found`);
             }
@@ -374162,6 +374301,7 @@ var sdk_metrics_build_src = __nccwpck_require__(84016);
 
 
 
+
 const INTERVAL_IN_SEGS = 60;
 class CRStateMetrics {
     constructor(kind, namespace, meter) {
@@ -374184,6 +374324,9 @@ class CRStateMetrics {
         this.deletedGauge = meter.createGauge('firestartr_deleted_total', {
             description: 'Total number of CRs in DELETED state',
         });
+        this.errorOnSyncGauge = meter.createGauge('firestartr_error_on_sync_total', {
+            description: 'Total number of CRs with failed SYNCs',
+        });
         this.namespace = namespace;
     }
     async start() {
@@ -374212,10 +374355,18 @@ class CRStateMetrics {
             let errorCount = 0;
             let planningCount = 0;
             let deletedCount = 0;
+            let errorOnSyncCount = 0;
             for (const item of items) {
                 const status = item.status?.conditions.find((condition) => condition.type !== 'SYNCHRONIZED' && condition.status === 'True');
                 if (!status)
                     continue;
+                const syncCondition = item.status.conditions.find((condition) => {
+                    return condition.type === 'SYNCHRONIZED';
+                });
+                if (syncCondition &&
+                    syncCondition.message === SYNC_DEFAULT_ERROR_MESSAGE) {
+                    errorOnSyncCount++;
+                }
                 switch (status.type) {
                     case 'PROVISIONED':
                         provisionedCount++;
@@ -374261,6 +374412,10 @@ class CRStateMetrics {
                 namespace: this.namespace,
                 kind: this.kind,
             });
+            this.errorOnSyncGauge.record(errorOnSyncCount, {
+                namespace: this.namespace,
+                kind: this.kind,
+            });
         }
         catch (err) {
             console.log(`CRStateMetrics: update ${err}`);

package/build/packages/cdk8s_renderer/imports/firestartr.dev.d.ts

@@ -2491,7 +2491,9 @@ export declare enum FirestartrTerraformWorkspaceSpecReferencesRefKind {
     /** FirestartrTerraformWorkspace */
     FIRESTARTR_TERRAFORM_WORKSPACE = "FirestartrTerraformWorkspace",
     /** ExternalSecret */
-    EXTERNAL_SECRET = "ExternalSecret"
+    EXTERNAL_SECRET = "ExternalSecret",
+    /** Secret */
+    SECRET = "Secret"
 }
 /**
  * @schema FirestartrTerraformWorkspaceSpecContextBackendRefKind

package/build/packages/cdk8s_renderer/src/refsSorter/refsExtractor.d.ts

@@ -2,5 +2,5 @@ import { RenderClaims } from '../renderer/types';
 export declare function extractRefs(renderClaims: RenderClaims, kind: string): any;
 export declare function extractAllRefs(claimData: string): any[];
 export declare function getGroupParentRef(parent: string, references?: any[]): any[];
-export declare function getTfWorkspacesRefs(values: any, references?: any[]): any[];
+export declare function getTfWorkspacesRefs(values: any, references?: any[], secretsRefs?: any[]): any[][];
 export declare function getComponentVarsAndSecretsRefs(parsedClaim: any): string[];

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

@@ -5,7 +5,6 @@ export interface ConfigFile {
     dest: string;
     src: string;
     user_managed: boolean;
-    target_branch: string;
 }
 export interface FeatureConfig {
     files?: ConfigFile[];
@@ -15,7 +14,6 @@ export interface ExpectedFile {
     localPath: string;
     repoPath: string;
     userManaged: boolean;
-    targetBranch: string;
 }
 export interface ExpectedOutput {
     files: ExpectedFile[];

package/build/packages/operator/src/metrics/CRStates.d.ts

@@ -8,6 +8,7 @@ export default class CRStateMetrics {
     planningGauge: any;
     deletedGauge: any;
     errorGauge: any;
+    errorOnSyncGauge: any;
     onUpdate: boolean;
     namespace: string;
     kc: any;

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

@@ -14,6 +14,7 @@ export type SyncStatus = {
     syncStatusPresent?: boolean;
     intervalLapsed?: boolean;
     syncMode?: SyncMode;
+    hasSyncFailed?: boolean;
 };
 export type SyncWatcher = {
     itemPath: string;

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

@@ -1,3 +1,4 @@
 export declare const APPLY_DEFAULT_ERROR_MESSAGE = "An error occurred while executing the Terraform apply operation.";
 export declare const DESTROY_DEFAULT_ERROR_MESSAGE = "An error occurred while executing the Terraform destroy operation.";
 export declare const PLAN_DEFAULT_ERROR_MESSAGE = "An error occurred while executing the Terraform plan operation.";
+export declare const SYNC_DEFAULT_ERROR_MESSAGE = "An error occurred while executing the Sync operation.";

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

@@ -1,2 +1,3 @@
 export { getRefNameFromKey, resolveRef, resolveScalar } from './resolver';
 export declare function resolveValues(values: any, refs: any): any;
+export declare function resolveClaimSecrets(values: any, refs: any): any;

package/build/packages/terraform_provisioner/src/resolutor/resolver.d.ts

@@ -1,3 +1,4 @@
 export declare function resolveScalar(value: any, refs: any): any;
 export declare function getRefNameFromKey(key: string): string;
+export declare function resolveClaimSecret(value: string, refs: any): any;
 export declare function resolveRef(key: string, references: any, wantsInterpolation?: boolean): any;

package/package.json

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