@contentstack/cli-audit 1.0.0

package/lib/modules/global-fields.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const content_types_1 = tslib_1.__importDefault(require("./content-types"));
+class GlobalField extends content_types_1.default {
+    /**
+     * The above function is an asynchronous function that runs a validation and returns any missing
+     * references.
+     * @returns the value of the variable `missingRefs`.
+     */
+    async run() {
+        // NOTE add any validation if required
+        const missingRefs = await super.run();
+        return missingRefs;
+    }
+    /**
+     * The function validates a field containing modular blocks by traversing each block and checking for
+     * references in a given tree.
+     * @param {Record<string, unknown>[]} tree - The `tree` parameter is an array of objects that
+     * represents a tree structure. Each object in the array represents a node in the tree.
+     * @param {ModularBlocksDataType} field - The `field` parameter is of type `ModularBlocksDataType`.
+     */
+    async validateModularBlocksField(tree, field) {
+        const { blocks } = field;
+        // NOTE Traverse each and every module and look for reference
+        for (const block of blocks) {
+            await this.lookForReference(tree, block);
+        }
+    }
+    /**
+     * The function "validateGroupField" performs group field validation by looking for a reference in a
+     * tree structure.
+     * @param {Record<string, unknown>[]} tree - The `tree` parameter is an array of objects representing
+     * a tree structure. Each object in the array represents a node in the tree and has properties like
+     * `uid` and `name`.
+     * @param {GroupFieldDataType} field - The `field` parameter is of type `GroupFieldDataType`.
+     */
+    async validateGroupField(tree, field) {
+        // NOTE Any Group Field related logic can be added here (Ex data serialization or picking any metadata for report etc.,)
+        await this.lookForReference([...tree, { uid: field.uid, name: field.display_name }], field);
+    }
+}
+exports.default = GlobalField;

package/lib/modules/index.d.ts

@@ -0,0 +1,4 @@
+import Entries from "./entries";
+import GlobalField from "./global-fields";
+import ContentType from "./content-types";
+export { Entries, GlobalField, ContentType };

package/lib/modules/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentType = exports.GlobalField = exports.Entries = void 0;
+const tslib_1 = require("tslib");
+const entries_1 = tslib_1.__importDefault(require("./entries"));
+exports.Entries = entries_1.default;
+const global_fields_1 = tslib_1.__importDefault(require("./global-fields"));
+exports.GlobalField = global_fields_1.default;
+const content_types_1 = tslib_1.__importDefault(require("./content-types"));
+exports.ContentType = content_types_1.default;

package/lib/types/content-types.d.ts

@@ -0,0 +1,69 @@
+import config from '../config';
+import { ConfigType, LogFn } from './utils';
+type ContentTypeStruct = {
+    uid: string;
+    title: string;
+    description: string;
+    schema?: (ReferenceFieldDataType | GlobalFieldDataType | CustomFieldDataType | JsonRTEFieldDataType | GroupFieldDataType | ModularBlocksDataType)[];
+};
+type ModuleConstructorParam = {
+    log: LogFn;
+    config: ConfigType;
+    moduleName?: keyof typeof config.moduleConfig;
+};
+type CtConstructorParam = {
+    gfSchema: ContentTypeStruct[] | [];
+    ctSchema: ContentTypeStruct[] | [];
+};
+type CommonDataTypeStruct = {
+    uid: string;
+    data_type: string;
+    display_name: string;
+    field_metadata: {
+        extension: boolean;
+        ref_multiple: boolean;
+        allow_json_rte: boolean;
+    } & Record<string, unknown>;
+};
+type RefErrorReturnType = {
+    name: string;
+    ct_uid: string;
+    treeStr: string;
+    data_type: string;
+    missingRefs: string[];
+    display_name: string;
+    tree: Record<string, unknown>[];
+};
+type ReferenceFieldDataType = CommonDataTypeStruct & {
+    reference_to: string[];
+};
+type GlobalFieldDataType = CommonDataTypeStruct & {
+    reference_to: string;
+    schema: GlobalFieldSchemaTypes[];
+};
+type CustomFieldDataType = CommonDataTypeStruct & {};
+type JsonRTEFieldDataType = CommonDataTypeStruct & {
+    reference_to: string[];
+};
+type GroupFieldDataType = CommonDataTypeStruct & {
+    schema: GroupFieldSchemaTypes[];
+};
+type ModularBlockType = {
+    uid: string;
+    title: string;
+    schema: (JsonRTEFieldDataType | ModularBlocksDataType | ReferenceFieldDataType | CustomFieldDataType | GroupFieldDataType)[];
+};
+type ModularBlocksDataType = CommonDataTypeStruct & {
+    blocks: ModularBlockType[];
+};
+type GroupFieldSchemaTypes = GroupFieldDataType | CommonDataTypeStruct | GlobalFieldDataType | ReferenceFieldDataType;
+type GlobalFieldSchemaTypes = ReferenceFieldDataType | GroupFieldDataType | CustomFieldDataType;
+type ModularBlocksSchemaTypes = ReferenceFieldDataType | JsonRTEFieldDataType;
+declare enum OutputColumn {
+    Title = "name",
+    'Field name' = "display_name",
+    'Field type' = "data_type",
+    'Missing references' = "missingRefs",
+    Path = "treeStr"
+}
+export { CtConstructorParam, ContentTypeStruct, ModuleConstructorParam, ReferenceFieldDataType, GlobalFieldDataType, CustomFieldDataType, JsonRTEFieldDataType, GroupFieldDataType, ModularBlocksDataType, RefErrorReturnType, ModularBlocksSchemaTypes, ModularBlockType, OutputColumn, };

package/lib/types/content-types.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutputColumn = void 0;
+var OutputColumn;
+(function (OutputColumn) {
+    OutputColumn["Title"] = "name";
+    OutputColumn["Field name"] = "display_name";
+    OutputColumn["Field type"] = "data_type";
+    OutputColumn["Missing references"] = "missingRefs";
+    OutputColumn["Path"] = "treeStr";
+})(OutputColumn || (OutputColumn = {}));
+exports.OutputColumn = OutputColumn;

package/lib/types/entries.d.ts

@@ -0,0 +1,46 @@
+type Locale = {
+    uid: string;
+    code: string;
+    name: string;
+    fallback_locale: string | null;
+};
+type EntryStruct = {
+    uid: string;
+    title: string;
+} & {
+    [key: string]: EntryReferenceFieldDataType[] | EntryGlobalFieldDataType | EntryJsonRTEFieldDataType | EntryGroupFieldDataType | EntryModularBlocksDataType[];
+};
+type EntryReferenceFieldDataType = {
+    uid: string;
+    _content_type_uid: string;
+};
+type EntryGlobalFieldDataType = {
+    [key: string]: EntryStruct;
+};
+type EntryCustomFieldDataType = {
+    [key: string]: EntryStruct;
+};
+type EntryJsonRTEFieldDataType = {
+    uid: string;
+    attrs: Record<string, any>;
+    children: EntryJsonRTEFieldDataType[];
+};
+type EntryGroupFieldDataType = {
+    [key: string]: EntryReferenceFieldDataType[] | EntryGlobalFieldDataType | EntryJsonRTEFieldDataType;
+};
+type EntryModularBlockType = {
+    [key: string]: EntryJsonRTEFieldDataType | EntryModularBlocksDataType | EntryReferenceFieldDataType[] | EntryGroupFieldDataType;
+};
+type EntryModularBlocksDataType = {
+    [key: string]: EntryModularBlockType;
+};
+type EntryRefErrorReturnType = {
+    name: string;
+    uid: string;
+    treeStr: string;
+    data_type: string;
+    missingRefs: string[] | Record<string, unknown>[];
+    display_name: string;
+    tree: Record<string, unknown>[];
+};
+export { Locale, EntryStruct, EntryGlobalFieldDataType, EntryCustomFieldDataType, EntryJsonRTEFieldDataType, EntryGroupFieldDataType, EntryModularBlocksDataType, EntryReferenceFieldDataType, EntryRefErrorReturnType, };

package/lib/types/entries.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./utils";
+export * from './entries';
+export * from './content-types';

package/lib/types/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./utils"), exports);
+tslib_1.__exportStar(require("./entries"), exports);
+tslib_1.__exportStar(require("./content-types"), exports);

package/lib/types/utils.d.ts

@@ -0,0 +1,18 @@
+import { Color } from "chalk";
+import { PrintOptions } from "@contentstack/cli-utilities";
+import config from "../config";
+type LogFn = (message: string | any, logType?: LoggerType | PrintOptions | undefined) => void;
+type ExitFn = (code?: number | undefined) => void;
+type Partial<T> = {
+    [P in keyof T]?: T[P];
+};
+type ConfigType = {
+    config?: string;
+} & typeof config & Record<string, any>;
+export { LogFn, ExitFn, Partial, ConfigType };
+export type LoggerType = "info" | "warn" | "error" | "debug";
+export type PrintType = {
+    message: string;
+    bold?: boolean;
+    color?: typeof Color;
+};

package/lib/types/utils.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/util/index.d.ts

@@ -0,0 +1 @@
+export { default as Logger } from "./log";

package/lib/util/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+var log_1 = require("./log");
+Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return __importDefault(log_1).default; } });

package/lib/util/log.d.ts

@@ -0,0 +1,42 @@
+import winston from 'winston';
+import { PrintOptions } from '@contentstack/cli-utilities';
+import { LoggerType, PrintType } from '../types';
+export default class Logger {
+    private infoLogger;
+    private errorLogger;
+    private config;
+    get loggerOptions(): winston.transports.FileTransportOptions;
+    constructor(config: Record<string, any>);
+    /**
+     * The function getLoggerInstance creates and returns a winston logger instance based on the provided
+     * log type.
+     * @param {LoggerType} logType - The `logType` parameter is a string that represents the type of log.
+     * It can have one of the following values: "error", "info", "debug", "warn", or any other custom log
+     * type.
+     * @returns an instance of the winston.Logger class.
+     */
+    getLoggerInstance(logType: LoggerType): winston.Logger;
+    /**
+     * The function `log` takes a message and an optional log type, and logs the message using different
+     * loggers based on the log type.
+     * @param {string | any} message - The `message` parameter is a string or any type of value that you
+     * want to log. It represents the content of the log message that you want to display.
+     * @param {LoggerType | PrintOptions | undefined} [logType] - The `logType` parameter is an optional
+     * parameter that specifies the type of log. It can be one of the following values:
+     */
+    log(message: string | any, logType?: LoggerType | PrintOptions | undefined): void;
+    /**
+     * The function `returnString` takes a message as input and returns a modified version of the message
+     * with sensitive credentials replaced and any ANSI escape codes removed.
+     * @param {any} message - The `message` parameter can be of any type. It can be a string, an object, or
+     * an array.
+     * @returns a string.
+     */
+    returnString(message: any): string;
+}
+/**
+ * The `print` function takes an array of `PrintType` objects, formats the messages using the `chalk`
+ * library for styling, and prints the formatted messages using the `ux.print` function.
+ * @param printInput - An array of objects with the following properties:
+ */
+export declare function print(printInput: Array<PrintType>): void;

package/lib/util/log.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.print = void 0;
+const tslib_1 = require("tslib");
+const map_1 = tslib_1.__importDefault(require("lodash/map"));
+const winston_1 = tslib_1.__importDefault(require("winston"));
+const fs_1 = require("fs");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const replace_1 = tslib_1.__importDefault(require("lodash/replace"));
+const isObject_1 = tslib_1.__importDefault(require("lodash/isObject"));
+const path_1 = require("path");
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const ansiRegexPattern = [
+    '[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)',
+    '(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))',
+].join('|');
+const customLevels = {
+    levels: {
+        warn: 1,
+        info: 2,
+        debug: 3,
+    },
+};
+/* The Logger class is a TypeScript class that provides logging functionality with different log levels
+and options. */
+class Logger {
+    get loggerOptions() {
+        return {
+            filename: '',
+            maxFiles: 20,
+            tailable: true,
+            maxsize: 1000000,
+        };
+    }
+    constructor(config) {
+        this.config = config;
+        this.infoLogger = this.getLoggerInstance('info');
+        this.errorLogger = this.getLoggerInstance('error');
+    }
+    /**
+     * The function getLoggerInstance creates and returns a winston logger instance based on the provided
+     * log type.
+     * @param {LoggerType} logType - The `logType` parameter is a string that represents the type of log.
+     * It can have one of the following values: "error", "info", "debug", "warn", or any other custom log
+     * type.
+     * @returns an instance of the winston.Logger class.
+     */
+    getLoggerInstance(logType) {
+        const consoleOptions = {
+            format: winston_1.default.format.combine(winston_1.default.format.simple(), winston_1.default.format.colorize({ all: true })),
+        };
+        if (logType === 'error') {
+            consoleOptions.level = logType;
+        }
+        if ((0, fs_1.existsSync)(this.config.basePath)) {
+            const filename = (0, path_1.normalize)((0, path_1.resolve)(this.config.basePath, 'logs', `${logType}.log`)).replace(/^(\.\.(\/|\\|$))+/, '');
+            const loggerOptions = {
+                transports: [
+                    new winston_1.default.transports.File(Object.assign(Object.assign({}, this.loggerOptions), { level: logType, filename })),
+                    new winston_1.default.transports.Console(consoleOptions),
+                ],
+                levels: customLevels.levels,
+            };
+            if (logType === 'error') {
+                loggerOptions.levels = { error: 0 };
+            }
+            return winston_1.default.createLogger(loggerOptions);
+        }
+        winston_1.default
+            .createLogger({
+            transports: [new winston_1.default.transports.Console(consoleOptions)],
+        })
+            .error('Provided base path is not valid');
+        throw new Error('Provided base path is not valid');
+    }
+    /**
+     * The function `log` takes a message and an optional log type, and logs the message using different
+     * loggers based on the log type.
+     * @param {string | any} message - The `message` parameter is a string or any type of value that you
+     * want to log. It represents the content of the log message that you want to display.
+     * @param {LoggerType | PrintOptions | undefined} [logType] - The `logType` parameter is an optional
+     * parameter that specifies the type of log. It can be one of the following values:
+     */
+    log(message, logType) {
+        const logString = this.returnString(message);
+        switch (logType) {
+            case 'info':
+            case 'debug':
+            case 'warn':
+                this.infoLogger.log(logType, logString);
+                break;
+            case 'error':
+                this.errorLogger.error(logString);
+                break;
+            default:
+                cli_utilities_1.cliux.print(logString, logType || {});
+                break;
+        }
+    }
+    /**
+     * The function `returnString` takes a message as input and returns a modified version of the message
+     * with sensitive credentials replaced and any ANSI escape codes removed.
+     * @param {any} message - The `message` parameter can be of any type. It can be a string, an object, or
+     * an array.
+     * @returns a string.
+     */
+    returnString(message) {
+        let returnStr = '';
+        const replaceCredentials = (item) => {
+            try {
+                return JSON.stringify(item).replace(/authtoken":"abc................/g, 'authtoken":"abc....');
+            }
+            catch (error) { }
+            return item;
+        };
+        if (Array.isArray(message) && message.length) {
+            returnStr = (0, map_1.default)(message, (item) => {
+                if (item && typeof item === 'object') {
+                    return replaceCredentials(item);
+                }
+                return item;
+            })
+                .join('  ')
+                .trim();
+        }
+        else if ((0, isObject_1.default)(message)) {
+            return replaceCredentials(message);
+        }
+        else {
+            returnStr = message;
+        }
+        returnStr = (0, replace_1.default)(returnStr, new RegExp(ansiRegexPattern, 'g'), '').trim();
+        return returnStr;
+    }
+}
+exports.default = Logger;
+/**
+ * The `print` function takes an array of `PrintType` objects, formats the messages using the `chalk`
+ * library for styling, and prints the formatted messages using the `ux.print` function.
+ * @param printInput - An array of objects with the following properties:
+ */
+function print(printInput) {
+    const str = (0, map_1.default)(printInput, ({ message, bold, color }) => {
+        let chalkFn = chalk_1.default;
+        if (color)
+            chalkFn = chalkFn[color];
+        if (bold)
+            chalkFn = chalkFn.bold;
+        return chalkFn(message);
+    }).join(' ');
+    cli_utilities_1.cliux.print(str);
+}
+exports.print = print;

package/oclif.manifest.json

@@ -0,0 +1,134 @@
+{
+  "version": "1.0.0",
+  "commands": {
+    "cm:stacks:audit:fix": {
+      "id": "cm:stacks:audit:fix",
+      "description": "Audit fix command",
+      "strict": true,
+      "pluginName": "@contentstack/cli-audit",
+      "pluginAlias": "@contentstack/cli-audit",
+      "pluginType": "core",
+      "aliases": [
+        "cm::stacks:audit:fix"
+      ],
+      "examples": [
+        "$ <%= config.bin %> <%= command.id %>"
+      ],
+      "flags": {
+        "config": {
+          "name": "config",
+          "type": "option",
+          "char": "c",
+          "description": "Path of the external config.",
+          "multiple": false
+        },
+        "data-dir": {
+          "name": "data-dir",
+          "type": "option",
+          "char": "d",
+          "description": "Path where the data is stored.",
+          "multiple": false
+        }
+      },
+      "args": {}
+    },
+    "cm:stacks:audit": {
+      "id": "cm:stacks:audit",
+      "description": "Perform audits and find possible errors in the exported Contentstack data",
+      "strict": true,
+      "pluginName": "@contentstack/cli-audit",
+      "pluginAlias": "@contentstack/cli-audit",
+      "pluginType": "core",
+      "aliases": [
+        "cm:stacks:audit"
+      ],
+      "examples": [
+        "$ <%= config.bin %> <%= command.id %>",
+        "$ <%= config.bin %> <%= command.id %> --report-path=<path>",
+        "$ <%= config.bin %> <%= command.id %> --report-path=<path> --csv",
+        "$ <%= config.bin %> <%= command.id %> --report-path=<path> --filter=\"name=<filter-value>\"",
+        "$ <%= config.bin %> <%= command.id %> --report-path=<path> --modules=content-types --filter=\"name=\"<filter-value>\""
+      ],
+      "flags": {
+        "config": {
+          "name": "config",
+          "type": "option",
+          "char": "c",
+          "description": "Path of the external config.",
+          "multiple": false
+        },
+        "data-dir": {
+          "name": "data-dir",
+          "type": "option",
+          "char": "d",
+          "description": "Path where the data is stored.",
+          "multiple": false
+        },
+        "report-path": {
+          "name": "report-path",
+          "type": "option",
+          "description": "Path to store the audit reports.",
+          "multiple": false
+        },
+        "reference-only": {
+          "name": "reference-only",
+          "type": "boolean",
+          "description": "Checks only for missing references.",
+          "hidden": true,
+          "allowNo": false
+        },
+        "modules": {
+          "name": "modules",
+          "type": "option",
+          "description": "Provide the list of modules to be audited.",
+          "multiple": true,
+          "options": [
+            "content-types",
+            "global-fields",
+            "entries"
+          ]
+        },
+        "columns": {
+          "name": "columns",
+          "type": "option",
+          "description": "only show provided columns (comma-separated)",
+          "multiple": false,
+          "exclusive": [
+            "extended"
+          ]
+        },
+        "sort": {
+          "name": "sort",
+          "type": "option",
+          "description": "property to sort by (prepend '-' for descending)",
+          "multiple": false
+        },
+        "filter": {
+          "name": "filter",
+          "type": "option",
+          "description": "filter property by partial string matching, ex: name=foo",
+          "multiple": false
+        },
+        "csv": {
+          "name": "csv",
+          "type": "boolean",
+          "description": "output is csv format [alias: --output=csv]",
+          "allowNo": false,
+          "exclusive": [
+            "no-truncate"
+          ]
+        },
+        "no-truncate": {
+          "name": "no-truncate",
+          "type": "boolean",
+          "description": "do not truncate output to fit screen",
+          "allowNo": false,
+          "exclusive": [
+            "csv"
+          ]
+        }
+      },
+      "args": {}
+    }
+  }
+}

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "@contentstack/cli-audit",
+  "version": "1.0.0",
+  "description": "Contentstack audit plugin",
+  "author": "Contentstack CLI",
+  "homepage": "https://github.com/contentstack/cli",
+  "license": "MIT",
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "bin": {
+    "audit": "./bin/run"
+  },
+  "repository": "contentstack/audit",
+  "files": [
+    "/bin",
+    "/lib",
+    "/npm-shrinkwrap.json",
+    "/oclif.manifest.json"
+  ],
+  "dependencies": {
+    "@contentstack/cli-command": "~1.2.11",
+    "@contentstack/cli-utilities": "~1.5.1",
+    "@oclif/plugin-help": "^5.2.20",
+    "@oclif/plugin-plugins": "^3.8.4",
+    "chalk": "^4.1.2",
+    "fast-csv": "^4.3.6",
+    "lodash": "^4.17.21",
+    "winston": "^3.9.0"
+  },
+  "devDependencies": {
+    "@oclif/test": "^2.0.3",
+    "@types/chai": "^4.3.5",
+    "@types/node": "^20.3.1",
+    "chai": "^4.3.7",
+    "eslint": "^8.43.0",
+    "eslint-config-oclif": "^4.0.0",
+    "eslint-config-oclif-typescript": "^1.0.3",
+    "mocha": "^10.2.0",
+    "nyc": "^15.1.0",
+    "oclif": "^3.10.0",
+    "shx": "^0.3.4",
+    "ts-node": "^10.9.1",
+    "tslib": "^2.5.3",
+    "typescript": "^5.1.3"
+  },
+  "oclif": {
+    "bin": "csdx",
+    "commands": "./lib/commands",
+    "plugins": [
+      "@oclif/plugin-help",
+      "@oclif/plugin-plugins"
+    ],
+    "topicSeparator": ":",
+    "additionalHelpFlags": [
+      "-h"
+    ],
+    "additionalVersionFlags": [
+      "-v"
+    ],
+    "topics": {
+      "cm:stacks:audit": {
+        "description": "Audit and find possible refrence errors in the exported data"
+      }
+    },
+    "repositoryPrefix": "<%- repo %>/blob/main/packages/contentstack-audit/<%- commandPath %>"
+  },
+  "scripts": {
+    "build": "npm run clean && shx rm -rf lib && tsc -b",
+    "lint": "eslint . --ext .ts --config .eslintrc",
+    "postpack": "shx rm -f oclif.manifest.json",
+    "posttest": "npm run lint",
+    "prepack": "npm run build && oclif manifest && oclif readme",
+    "test": "mocha --forbid-only \"test/**/*.test.ts\"",
+    "version": "oclif readme && git add README.md",
+    "clean": "rm -rf ./lib ./node_modules tsconfig.tsbuildinfo oclif.manifest.json",
+    "test:unit:report": "nyc --extension .ts mocha --forbid-only \"test/unit/**/*.test.ts\""
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "bugs": "https://github.com/contentstack/cli/issues",
+  "keywords": [
+    "oclif"
+  ]
+}