@contentstack/cli-utilities 1.11.0 → 1.12.0

package/lib/authentication-handler.js

@@ -49,13 +49,6 @@ class AuthenticationHandler {
     }
     async refreshAccessToken(error, maxRetryCount = 1) {
         if (error.response && error.response.status) {
-            if (maxRetryCount >= 3) {
-                index_1.cliux.print('Max retry count reached, please login to proceed', {
-                    color: 'yellow',
-                });
-                process.exit(1);
-            }
-            maxRetryCount++; // Increment for the next retry attempt
             switch (error.response.status) {
                 case 401:
                     // NOTE: Refresh the token if the type is OAuth.
@@ -68,11 +61,24 @@ class AuthenticationHandler {
                                 hostName = u.host;
                         }
                         hostName = hostName || region.cma;
-                        await this.refreshToken(hostName);
-                        return this.refreshAccessToken(error, maxRetryCount); // Retry after refreshing the token
+                        const refreshed = await this.refreshToken(hostName);
+                        if (refreshed) {
+                            return this.refreshAccessToken(error, maxRetryCount); // Retry after refreshing the token
+                        }
+                        console.log('API(401) case error:-', error.response);
+                        // For Basic Auth, exit immediately without retrying
+                        return;
                     }
+                    break;
                 case 429:
                 case 408:
+                    if (maxRetryCount >= 3) {
+                        index_1.cliux.print('Max retry count reached, please login to proceed', {
+                            color: 'yellow',
+                        });
+                        process.exit(1);
+                    }
+                    maxRetryCount++; // Increment for the next retry attempt
                     // These cases require a wait, adding a delay before retrying
                     await new Promise((resolve) => setTimeout(resolve, 1000)); // wait for 1 second
                     return this.refreshAccessToken(error, maxRetryCount); // Retry
@@ -84,8 +90,6 @@ class AuthenticationHandler {
     refreshToken(hostName) {
         return new Promise((resolve) => {
             if (this.authType === 'BASIC') {
-                // NOTE Handle basic auth 401 here
-                resolve(false);
                 index_1.cliux.print('Session timed out, please login to proceed', {
                     color: 'yellow',
                 });
@@ -106,7 +110,6 @@ class AuthenticationHandler {
                 });
             }
             else {
-                resolve(false);
                 index_1.cliux.print('You do not have the permissions to perform this action, please login to proceed', {
                     color: 'yellow',
                 });

package/lib/config-handler.d.ts

@@ -5,6 +5,8 @@ declare class Config {
     init(): Conf<Record<string, unknown>>;
     importOldConfig(): void;
     setOldConfigStoreData(data: any, _path?: string): void;
+    isConfigFileValid(configPath: string): boolean;
+    safeDeleteConfigIfInvalid(configFilePath: string): void;
     removeOldConfigStoreFile(): void;
     private getOldConfig;
     private fallbackInit;

package/lib/config-handler.js

@@ -56,6 +56,22 @@ class Config {
             }
         }
     }
+    isConfigFileValid(configPath) {
+        try {
+            const content = (0, fs_1.readFileSync)(configPath, 'utf8');
+            JSON.parse(content);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    safeDeleteConfigIfInvalid(configFilePath) {
+        if ((0, fs_1.existsSync)(configFilePath) && !this.isConfigFileValid(configFilePath)) {
+            console.warn(chalk_1.default.yellow(`Warning: Detected corrupted config at ${configFilePath}. Removing...`));
+            (0, fs_1.unlinkSync)(configFilePath);
+        }
+    }
     removeOldConfigStoreFile() {
         if ((0, fs_1.existsSync)(oldConfigPath)) {
             (0, fs_1.unlinkSync)(oldConfigPath); // NOTE remove old configstore file
@@ -98,6 +114,7 @@ class Config {
             try {
                 // NOTE reading current code base encrypted file if exist
                 const encryptionKey = this.getObfuscationKey();
+                this.safeDeleteConfigIfInvalid(oldConfigPath);
                 this.config = new conf_1.default({ configName: CONFIG_NAME, encryptionKey, cwd });
                 if ((_a = Object.keys(configData || {})) === null || _a === void 0 ? void 0 : _a.length) {
                     this.config.set(configData); // NOTE set config data if passed any
@@ -119,6 +136,7 @@ class Config {
         };
         try {
             if (skip === false) {
+                this.safeDeleteConfigIfInvalid(oldConfigPath);
                 const config = new conf_1.default({ configName: CONFIG_NAME });
                 const oldConfigData = this.getConfigDataAndUnlinkConfigFile(config);
                 this.getEncryptedConfig(oldConfigData, true);
@@ -137,6 +155,7 @@ class Config {
     getDecryptedConfig(configData) {
         var _a;
         try {
+            this.safeDeleteConfigIfInvalid(oldConfigPath);
             this.config = new conf_1.default({ configName: CONFIG_NAME, cwd });
             if ((_a = Object.keys(configData || {})) === null || _a === void 0 ? void 0 : _a.length) {
                 this.config.set(configData); // NOTE set config data if passed any
@@ -146,6 +165,7 @@ class Config {
             // console.trace(error.message)
             try {
                 const encryptionKey = this.getObfuscationKey();
+                this.safeDeleteConfigIfInvalid(oldConfigPath);
                 let config = new conf_1.default({ configName: CONFIG_NAME, encryptionKey, cwd });
                 const oldConfigData = this.getConfigDataAndUnlinkConfigFile(config);
                 this.getDecryptedConfig(oldConfigData); // NOTE NOTE reinitialize the config with old data and new decrypted file

package/lib/constants/errorTypes.d.ts

@@ -0,0 +1,10 @@
+export declare const ERROR_TYPES: {
+    readonly NETWORK: "NETWORK_ERROR";
+    readonly DATABASE: "DATABASE_ERROR";
+    readonly APPLICATION: "APPLICATION_ERROR";
+    readonly UNKNOWN: "UNKNOWN_ERROR";
+    readonly NORMALIZATION: "NORMALIZATION_ERROR";
+    readonly API_RESPONSE: "API_RESPONSE_DATA";
+    readonly API_ERROR: "API_ERROR";
+    readonly SERVER_ERROR: "SERVER_ERROR";
+};

package/lib/constants/errorTypes.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERROR_TYPES = void 0;
+exports.ERROR_TYPES = {
+    NETWORK: 'NETWORK_ERROR',
+    DATABASE: 'DATABASE_ERROR',
+    APPLICATION: 'APPLICATION_ERROR',
+    UNKNOWN: 'UNKNOWN_ERROR',
+    NORMALIZATION: 'NORMALIZATION_ERROR',
+    API_RESPONSE: 'API_RESPONSE_DATA',
+    API_ERROR: 'API_ERROR',
+    SERVER_ERROR: 'SERVER_ERROR',
+};

package/lib/constants/logging.d.ts

@@ -0,0 +1,15 @@
+export declare const logLevels: {
+    readonly error: 0;
+    readonly warn: 1;
+    readonly info: 2;
+    readonly success: 2;
+    readonly debug: 3;
+    readonly verbose: 4;
+};
+export declare const levelColors: {
+    error: string;
+    warn: string;
+    success: string;
+    info: string;
+    debug: string;
+};

package/lib/constants/logging.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.levelColors = exports.logLevels = void 0;
+exports.logLevels = {
+    error: 0,
+    warn: 1,
+    info: 2,
+    success: 2,
+    debug: 3,
+    verbose: 4
+};
+// 2. Create color mappings (for console only)
+exports.levelColors = {
+    error: 'red',
+    warn: 'yellow',
+    success: 'green',
+    info: 'blue',
+    debug: 'white'
+};

package/lib/interfaces/index.d.ts

@@ -1,3 +1,4 @@
+import { logLevels } from "../constants/logging";
 export interface IPromptOptions {
     prompt?: string;
     type?: 'normal' | 'mask' | 'hide' | 'single';
@@ -62,3 +63,37 @@ export interface Locale {
 }
 export interface CliUXPromptOptions extends IPromptOptions {
 }
+export interface LoggerConfig {
+    basePath: string;
+    processName?: string;
+    consoleLoggingEnabled?: boolean;
+    consoleLogLevel?: LogType;
+    logLevel?: LogType;
+}
+export interface PrintOptions {
+    bold?: boolean;
+    color?: string;
+}
+export type LogType = 'info' | 'warn' | 'error' | 'debug';
+export type LogsType = LogType | PrintOptions | undefined;
+export type MessageType = string | Error | Record<string, any> | Record<string, any>[];
+export type LogLevel = keyof typeof logLevels;
+export type ClassifiedError = {
+    type: string;
+    message: string;
+    error: Record<string, any>;
+    debug?: Record<string, any>;
+    meta?: Record<string, string | undefined>;
+    context?: string;
+    hidden?: boolean;
+};
+export type ErrorContext = {
+    operation?: string;
+    component?: string;
+    userId?: string;
+    requestId?: string;
+    email?: string;
+    sessionId?: string;
+    orgId?: string;
+    apiKey?: string;
+};

package/lib/logger/cliErrorHandler.d.ts

@@ -0,0 +1,64 @@
+import { ClassifiedError, ErrorContext } from '../interfaces';
+/**
+ * Handles errors in a CLI application by classifying, normalizing, and extracting
+ * relevant information for debugging and logging purposes.
+ *
+ * This class provides methods to:
+ * - Normalize unknown error types into standard `Error` objects.
+ * - Classify errors into predefined categories such as API errors, network errors,
+ *   server errors, and more.
+ * - Extract detailed error payloads for logging, including HTTP request and response
+ *   details when applicable.
+ * - Identify sensitive information in error messages to prevent accidental exposure.
+ * - Generate debug payloads for enhanced troubleshooting when debugging is enabled.
+ *
+ * @remarks
+ * This class is designed to handle a wide range of error types, including generic
+ * JavaScript errors, API errors, and custom error objects. It also supports
+ * optional debugging and context metadata for enhanced error reporting.
+ *
+ * @example
+ * ```typescript
+ * const errorHandler = new CLIErrorHandler(true);
+ *
+ * try {
+ *   // Some operation that may throw an error
+ * } catch (error) {
+ *   const classifiedError = errorHandler.classifyError(error, {
+ *     operation: 'fetchData',
+ *     component: 'DataService',
+ *   });
+ *   console.error(classifiedError);
+ * }
+ * ```
+ *
+ * @public
+ */
+export default class CLIErrorHandler {
+    private isDebug;
+    constructor(isDebug?: boolean);
+    /**
+     * Classifies an error into a structured format for better handling and debugging.
+     *
+     * @param error - The error object to classify. Can be of any type.
+     * @param context - Optional additional context about the error, typically used to provide
+     *                  more information about where or why the error occurred.
+     *
+     * @returns A `ClassifiedError` object containing details about the error, including its type,
+     *          message, payload, context, metadata, and whether it contains sensitive information.
+     *          If the error is an API error or debugging is enabled, additional debug information
+     *          is included.
+     *
+     * @throws This method handles its own errors and will return a `ClassifiedError` with type
+     *         `ERROR_TYPES.NORMALIZATION` if it fails to normalize or classify the input error.
+     */
+    classifyError(error: unknown, context?: ErrorContext): ClassifiedError;
+    private normalizeToError;
+    private isApiError;
+    private determineErrorType;
+    private extractErrorPayload;
+    private extractDebugPayload;
+    private extractMeta;
+    private containsSensitiveInfo;
+}
+export { CLIErrorHandler };

package/lib/logger/cliErrorHandler.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLIErrorHandler = void 0;
+const helpers_1 = require("../helpers");
+const errorTypes_1 = require("../constants/errorTypes");
+/**
+ * Handles errors in a CLI application by classifying, normalizing, and extracting
+ * relevant information for debugging and logging purposes.
+ *
+ * This class provides methods to:
+ * - Normalize unknown error types into standard `Error` objects.
+ * - Classify errors into predefined categories such as API errors, network errors,
+ *   server errors, and more.
+ * - Extract detailed error payloads for logging, including HTTP request and response
+ *   details when applicable.
+ * - Identify sensitive information in error messages to prevent accidental exposure.
+ * - Generate debug payloads for enhanced troubleshooting when debugging is enabled.
+ *
+ * @remarks
+ * This class is designed to handle a wide range of error types, including generic
+ * JavaScript errors, API errors, and custom error objects. It also supports
+ * optional debugging and context metadata for enhanced error reporting.
+ *
+ * @example
+ * ```typescript
+ * const errorHandler = new CLIErrorHandler(true);
+ *
+ * try {
+ *   // Some operation that may throw an error
+ * } catch (error) {
+ *   const classifiedError = errorHandler.classifyError(error, {
+ *     operation: 'fetchData',
+ *     component: 'DataService',
+ *   });
+ *   console.error(classifiedError);
+ * }
+ * ```
+ *
+ * @public
+ */
+class CLIErrorHandler {
+    constructor(isDebug = false) {
+        this.isDebug = isDebug;
+    }
+    /**
+     * Classifies an error into a structured format for better handling and debugging.
+     *
+     * @param error - The error object to classify. Can be of any type.
+     * @param context - Optional additional context about the error, typically used to provide
+     *                  more information about where or why the error occurred.
+     *
+     * @returns A `ClassifiedError` object containing details about the error, including its type,
+     *          message, payload, context, metadata, and whether it contains sensitive information.
+     *          If the error is an API error or debugging is enabled, additional debug information
+     *          is included.
+     *
+     * @throws This method handles its own errors and will return a `ClassifiedError` with type
+     *         `ERROR_TYPES.NORMALIZATION` if it fails to normalize or classify the input error.
+     */
+    classifyError(error, context) {
+        try {
+            const normalized = this.normalizeToError(error);
+            const isApi = this.isApiError(normalized);
+            const type = this.determineErrorType(normalized);
+            const hidden = this.containsSensitiveInfo(normalized);
+            const result = {
+                type,
+                message: normalized.message || 'Unhandled error',
+                error: this.extractErrorPayload(normalized),
+                context: context ? JSON.stringify(context) : undefined,
+                meta: this.extractMeta(context),
+                hidden,
+            };
+            if (isApi || this.isDebug) {
+                result.debug = this.extractDebugPayload(normalized, context);
+            }
+            return result;
+        }
+        catch (e) {
+            return {
+                type: errorTypes_1.ERROR_TYPES.NORMALIZATION,
+                message: 'Failed to normalize or classify error',
+                error: { message: String(e) },
+                context: context ? JSON.stringify(context) : undefined,
+                meta: this.extractMeta(context),
+                hidden: false,
+            };
+        }
+    }
+    normalizeToError(error) {
+        if (!error)
+            return new Error('Unknown error occurred');
+        if (error instanceof Error)
+            return error;
+        if (typeof error === 'string')
+            return new Error(error);
+        if (typeof error === 'object') {
+            try {
+                const msg = error.message;
+                const err = new Error(msg || 'Unknown error');
+                Object.assign(err, error);
+                return err;
+            }
+            catch (_a) {
+                return new Error(JSON.stringify(error));
+            }
+        }
+        return new Error(String(error));
+    }
+    isApiError(error) {
+        return (error.isAxiosError ||
+            typeof error.status === 'number' ||
+            typeof error.statusText === 'string' ||
+            error.request !== undefined);
+    }
+    determineErrorType(error) {
+        var _a;
+        const status = error.status || ((_a = error.response) === null || _a === void 0 ? void 0 : _a.status);
+        //Ignore 4XX errors
+        if (status >= 400 && status < 500) {
+            return errorTypes_1.ERROR_TYPES.API_ERROR;
+        }
+        //Server-side HTTP errors
+        if (status >= 500) {
+            return errorTypes_1.ERROR_TYPES.SERVER_ERROR;
+        }
+        //Network-related error
+        if (error.code === 'ECONNREFUSED' || error.code === 'ENOTFOUND' || error.code === 'ETIMEDOUT') {
+            return errorTypes_1.ERROR_TYPES.NETWORK;
+        }
+        //Database error
+        if (error.name === 'DatabaseError') {
+            return errorTypes_1.ERROR_TYPES.DATABASE;
+        }
+        //Axios errors without 4XX
+        if (error.isAxiosError) {
+            return errorTypes_1.ERROR_TYPES.NETWORK;
+        }
+        //Default
+        return errorTypes_1.ERROR_TYPES.APPLICATION;
+    }
+    extractErrorPayload(error) {
+        var _a, _b, _c, _d, _e, _f;
+        const code = error.code || error.errorCode;
+        const status = error.status || ((_a = error.response) === null || _a === void 0 ? void 0 : _a.status);
+        const statusText = error.statusText || ((_b = error.response) === null || _b === void 0 ? void 0 : _b.statusText);
+        const method = ((_c = error.request) === null || _c === void 0 ? void 0 : _c.method) || ((_d = error.config) === null || _d === void 0 ? void 0 : _d.method) || 'UNKNOWN';
+        const url = ((_e = error.request) === null || _e === void 0 ? void 0 : _e.url) || ((_f = error.config) === null || _f === void 0 ? void 0 : _f.url);
+        const endpoint = url ? new URL(url, 'http://dummy').pathname : 'UNKNOWN';
+        const payload = {
+            name: error.name,
+            message: (0, helpers_1.formatError)(error),
+            code,
+            status,
+            statusText,
+            method,
+            endpoint,
+        };
+        if (this.isDebug) {
+            payload.stack = error.stack;
+        }
+        return payload;
+    }
+    extractDebugPayload(error, context) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        const method = ((_a = error.request) === null || _a === void 0 ? void 0 : _a.method) || ((_b = error.config) === null || _b === void 0 ? void 0 : _b.method);
+        const url = ((_c = error.request) === null || _c === void 0 ? void 0 : _c.url) || ((_d = error.config) === null || _d === void 0 ? void 0 : _d.url);
+        const status = error.status || ((_e = error.response) === null || _e === void 0 ? void 0 : _e.status);
+        const statusText = error.statusText || ((_f = error.response) === null || _f === void 0 ? void 0 : _f.statusText);
+        const data = error.data || ((_g = error.response) === null || _g === void 0 ? void 0 : _g.data) || error.errors || error.error;
+        return {
+            command: context === null || context === void 0 ? void 0 : context.operation,
+            module: context === null || context === void 0 ? void 0 : context.component,
+            request: {
+                method,
+                url,
+                headers: (_h = error.request) === null || _h === void 0 ? void 0 : _h.headers,
+                data: (_j = error.request) === null || _j === void 0 ? void 0 : _j.data,
+            },
+            response: {
+                status,
+                statusText,
+                data,
+            },
+        };
+    }
+    extractMeta(context) {
+        return {
+            email: context === null || context === void 0 ? void 0 : context.email,
+            sessionId: context === null || context === void 0 ? void 0 : context.sessionId,
+            userId: context === null || context === void 0 ? void 0 : context.userId,
+            apiKey: context === null || context === void 0 ? void 0 : context.apiKey,
+            orgId: context === null || context === void 0 ? void 0 : context.orgId,
+        };
+    }
+    containsSensitiveInfo(error) {
+        try {
+            const content = `${error.message} ${error.stack || ''}`.toLowerCase();
+            return [
+                'password',
+                'token',
+                'secret',
+                'credentials',
+                'api_key',
+                'api-key',
+                'authorization',
+                'sessionid',
+                'email',
+            ].some((term) => content.includes(term));
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+}
+exports.default = CLIErrorHandler;
+exports.CLIErrorHandler = CLIErrorHandler;

package/lib/logger/log.d.ts

@@ -0,0 +1,23 @@
+import { default as Logger } from './logger';
+import { CLIErrorHandler } from './cliErrorHandler';
+import { ErrorContext } from '../interfaces';
+declare const v2Logger: Logger;
+declare const cliErrorHandler: CLIErrorHandler;
+/**
+ * Handles and logs an error by classifying it and logging the relevant details.
+ *
+ * This function uses the `cliErrorHandler` to classify the provided error and logs
+ * the error details using `v2Logger`. If debug information is available, it logs
+ * additional debug details, including a stack trace if not already present.
+ *
+ * @param error - The error to be handled and logged. Can be of any type.
+ * @param context - Optional context information to assist in error classification
+ *                  and logging.
+ *
+ * @remarks
+ * - The error is always logged with its type, message, and other metadata.
+ * - If debug information is available, it is logged separately with a more specific
+ *   debug type and additional details.
+ */
+declare function handleAndLogError(error: unknown, context?: ErrorContext): void;
+export { v2Logger, cliErrorHandler, handleAndLogError };

package/lib/logger/log.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleAndLogError = exports.cliErrorHandler = exports.v2Logger = void 0;
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+const logger_1 = tslib_1.__importDefault(require("./logger"));
+const cliErrorHandler_1 = require("./cliErrorHandler");
+const v2Logger = new logger_1.default({ basePath: process.env.CS_CLI_LOG_PATH || path.join(process.cwd(), 'logs') });
+exports.v2Logger = v2Logger;
+const cliErrorHandler = new cliErrorHandler_1.CLIErrorHandler(true); // Enable debug mode for error classification
+exports.cliErrorHandler = cliErrorHandler;
+/**
+ * Handles and logs an error by classifying it and logging the relevant details.
+ *
+ * This function uses the `cliErrorHandler` to classify the provided error and logs
+ * the error details using `v2Logger`. If debug information is available, it logs
+ * additional debug details, including a stack trace if not already present.
+ *
+ * @param error - The error to be handled and logged. Can be of any type.
+ * @param context - Optional context information to assist in error classification
+ *                  and logging.
+ *
+ * @remarks
+ * - The error is always logged with its type, message, and other metadata.
+ * - If debug information is available, it is logged separately with a more specific
+ *   debug type and additional details.
+ */
+function handleAndLogError(error, context) {
+    const classified = cliErrorHandler.classifyError(error, context);
+    // Always log the error
+    v2Logger.logError({
+        type: classified.type,
+        message: classified.message,
+        error: classified.error,
+        context: classified.context,
+        hidden: classified.hidden,
+        meta: classified.meta,
+    });
+    // Log debug information if available
+    if (classified.debug) {
+        v2Logger.logDebug({
+            type: `${classified.type}_DEBUG`,
+            message: `${classified.message} [DEBUG]`,
+            debug: Object.assign(Object.assign({}, classified.debug), { 
+                // Ensure stack trace is included if not already there
+                stackTrace: classified.debug.stackTrace || classified.error.stack }),
+            context: classified.context,
+            meta: classified.meta,
+        });
+    }
+}
+exports.handleAndLogError = handleAndLogError;

package/lib/logger/logger.d.ts

@@ -0,0 +1,57 @@
+import * as winston from 'winston';
+import { LoggerConfig } from '../interfaces/index';
+export default class Logger {
+    private loggers;
+    private config;
+    private sensitiveKeys;
+    constructor(config: LoggerConfig);
+    getLoggerInstance(level?: 'error' | 'info' | 'warn' | 'debug' | 'hidden'): winston.Logger;
+    private get loggerOptions();
+    private createLogger;
+    private isSensitiveKey;
+    private redactObject;
+    private redact;
+    private isLogEntry;
+    private shouldLog;
+    error(message: string, meta?: any): void;
+    warn(message: string, meta?: any): void;
+    info(message: string, meta?: any): void;
+    success(message: string, meta?: any): void;
+    debug(message: string, meta?: any): void;
+    logError(params: {
+        type: string;
+        message: string;
+        error: any;
+        context?: string;
+        hidden?: boolean;
+        meta?: Record<string, any>;
+    }): void;
+    logWarn(params: {
+        type: string;
+        message: string;
+        warn?: any;
+        context?: string;
+        meta?: Record<string, any>;
+    }): void;
+    logInfo(params: {
+        type: string;
+        message: string;
+        info?: any;
+        context?: string;
+        meta?: Record<string, any>;
+    }): void;
+    logSuccess(params: {
+        type: string;
+        message: string;
+        data?: any;
+        context?: string;
+        meta?: Record<string, any>;
+    }): void;
+    logDebug(params: {
+        type: string;
+        message: string;
+        debug?: any;
+        context?: string;
+        meta?: Record<string, any>;
+    }): void;
+}

package/lib/logger/logger.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const traverse_1 = tslib_1.__importDefault(require("traverse"));
+const full_1 = require("klona/full");
+const path_1 = require("path");
+const winston = tslib_1.__importStar(require("winston"));
+const logging_1 = require("../constants/logging");
+class Logger {
+    constructor(config) {
+        this.sensitiveKeys = [
+            /authtoken/i,
+            /^email$/i,
+            /^password$/i,
+            /secret/i,
+            /token/i,
+            /api[-._]?key/i,
+            /management[-._]?token/i,
+            /sessionid/i,
+            /orgid/i,
+        ];
+        this.config = config;
+        this.loggers = {
+            error: this.getLoggerInstance('error'),
+            warn: this.getLoggerInstance('warn'),
+            info: this.getLoggerInstance('info'),
+            debug: this.getLoggerInstance('debug'),
+            success: this.getLoggerInstance('info'), // Map success to info
+        };
+    }
+    getLoggerInstance(level = 'info') {
+        const filePath = (0, path_1.normalize)(process.env.CS_CLI_LOG_PATH || this.config.basePath).replace(/^(\.\.(\/|\\|$))+/, '');
+        if (level === 'hidden') {
+            return this.createLogger('error', filePath);
+        }
+        return this.createLogger(level, filePath);
+    }
+    get loggerOptions() {
+        return {
+            filename: '',
+            maxFiles: 20,
+            tailable: true,
+            maxsize: 1000000,
+        };
+    }
+    createLogger(level, filePath) {
+        return winston.createLogger({
+            levels: logging_1.logLevels,
+            level: level,
+            transports: [
+                new winston.transports.File(Object.assign(Object.assign({}, this.loggerOptions), { filename: `${filePath}/${level}.log`, format: winston.format.combine(winston.format.timestamp(), winston.format.json()) })),
+                new winston.transports.Console({
+                    format: winston.format.combine(winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }), winston.format.printf((info) => {
+                        const colorizer = winston.format.colorize();
+                        const levelText = info.level.toUpperCase();
+                        const timestamp = info.timestamp;
+                        const message = info.message;
+                        const meta = info.meta;
+                        let fullLine = `[${timestamp}] ${levelText}: ${message}`;
+                        if (meta && (info.level !== 'info' && info.level !== 'success')) {
+                            const redactedMeta = this.isLogEntry(meta) ? JSON.stringify(this.redact(meta)) : JSON.stringify(this.redact(meta));
+                            fullLine += ` - ${redactedMeta}`;
+                        }
+                        return colorizer.colorize(info.level, fullLine);
+                    })),
+                }),
+            ],
+        });
+    }
+    isSensitiveKey(keyStr) {
+        return keyStr && typeof keyStr === 'string'
+            ? this.sensitiveKeys.some((regex) => regex.test(keyStr))
+            : false;
+    }
+    redactObject(obj) {
+        const self = this;
+        (0, traverse_1.default)(obj).forEach(function redactor() {
+            if (this.key && self.isSensitiveKey(this.key)) {
+                this.update('[REDACTED]');
+            }
+        });
+    }
+    redact(info) {
+        try {
+            const copy = (0, full_1.klona)(info);
+            this.redactObject(copy);
+            const splat = copy[Symbol.for('splat')];
+            if (splat)
+                this.redactObject(splat);
+            return copy;
+        }
+        catch (error) {
+            return info;
+        }
+    }
+    isLogEntry(obj) {
+        return typeof obj === 'object' && 'level' in obj && 'message' in obj;
+    }
+    shouldLog(level, target) {
+        const configLevel = target === 'console' ? this.config.consoleLogLevel : this.config.logLevel;
+        const minLevel = configLevel ? logging_1.logLevels[configLevel] : 2; // default: info
+        const entryLevel = logging_1.logLevels[level];
+        return entryLevel <= minLevel;
+    }
+    /* === Public Log Methods === */
+    error(message, meta) {
+        if (this.shouldLog('error', 'console') || this.shouldLog('error', 'file')) {
+            this.loggers.error.error(message, meta);
+        }
+    }
+    warn(message, meta) {
+        if (this.shouldLog('warn', 'console') || this.shouldLog('warn', 'file')) {
+            this.loggers.warn.warn(message, meta);
+        }
+    }
+    info(message, meta) {
+        if (this.shouldLog('info', 'console') || this.shouldLog('info', 'file')) {
+            this.loggers.info.info(message, meta);
+        }
+    }
+    success(message, meta) {
+        if (this.shouldLog('info', 'console') || this.shouldLog('info', 'file')) {
+            this.loggers.success.info(message, Object.assign(Object.assign({}, meta), { type: 'success' }));
+        }
+    }
+    debug(message, meta) {
+        if (this.shouldLog('debug', 'console') || this.shouldLog('debug', 'file')) {
+            this.loggers.debug.debug(message, meta);
+        }
+    }
+    /* === Structured Logging === */
+    logError(params) {
+        const logPayload = {
+            level: logging_1.logLevels.error,
+            message: params.message,
+            timestamp: new Date(),
+            meta: Object.assign({ type: params.type, error: params.error, context: params.context }, params.meta),
+        };
+        const targetLevel = params.hidden ? 'debug' : 'error';
+        if (this.shouldLog(targetLevel, 'console') || this.shouldLog(targetLevel, 'file')) {
+            this.loggers[targetLevel].error(logPayload);
+        }
+    }
+    logWarn(params) {
+        const logPayload = {
+            level: logging_1.logLevels.warn,
+            message: params.message,
+            timestamp: new Date(),
+            meta: Object.assign({ type: params.type, context: params.context }, params.meta),
+        };
+        if (this.shouldLog('warn', 'console') || this.shouldLog('warn', 'file')) {
+            this.loggers.warn.warn(logPayload);
+        }
+    }
+    logInfo(params) {
+        const logPayload = {
+            level: logging_1.logLevels.info,
+            message: params.message,
+            timestamp: new Date(),
+            meta: Object.assign({ type: params.type, info: params.info, context: params.context }, params.meta),
+        };
+        if (this.shouldLog('info', 'console') || this.shouldLog('info', 'file')) {
+            this.loggers.info.info(logPayload);
+        }
+    }
+    logSuccess(params) {
+        const logPayload = {
+            level: logging_1.logLevels.success,
+            message: params.message,
+            timestamp: new Date(),
+            meta: Object.assign({ type: params.type, data: params.data, context: params.context }, params.meta),
+        };
+        if (this.shouldLog('info', 'console') || this.shouldLog('info', 'file')) {
+            this.loggers.success.info(logPayload);
+        }
+    }
+    logDebug(params) {
+        const logPayload = {
+            level: logging_1.logLevels.debug,
+            message: params.message,
+            timestamp: new Date(),
+            meta: Object.assign({ type: params.type, debug: params.debug, context: params.context }, params.meta),
+        };
+        if (this.shouldLog('debug', 'console') || this.shouldLog('debug', 'file')) {
+            this.loggers.debug.debug(logPayload);
+        }
+    }
+}
+exports.default = Logger;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentstack/cli-utilities",
-  "version": "1.11.0",
+  "version": "1.12.0",
   "description": "Utilities for contentstack projects",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -32,16 +32,16 @@
   "author": "contentstack",
   "license": "MIT",
   "dependencies": {
-    "@contentstack/management": "~1.20.1",
-    "@contentstack/marketplace-sdk": "^1.2.5",
-    "@oclif/core": "^4.2.7",
-    "axios": "^1.8.2",
+    "@contentstack/management": "~1.21.4",
+    "@contentstack/marketplace-sdk": "^1.2.8",
+    "@oclif/core": "^4.3.0",
+    "axios": "^1.9.0",
     "chalk": "^4.1.2",
     "cli-cursor": "^3.1.0",
     "cli-progress": "^3.12.0",
     "cli-table": "^0.3.11",
     "conf": "^10.2.0",
-    "dotenv": "^16.4.7",
+    "dotenv": "^16.5.0",
     "figures": "^3.2.0",
     "inquirer": "8.2.6",
     "inquirer-search-checkbox": "^1.0.0",
@@ -52,7 +52,7 @@
     "mkdirp": "^1.0.4",
     "open": "^8.4.2",
     "ora": "^5.4.1",
-    "papaparse": "^5.5.2",
+    "papaparse": "^5.5.3",
     "recheck": "~4.4.5",
     "rxjs": "^6.6.7",
     "traverse": "^0.6.11",
@@ -64,7 +64,7 @@
   },
   "devDependencies": {
     "@types/chai": "^4.3.20",
-    "@types/inquirer": "^9.0.7",
+    "@types/inquirer": "^9.0.8",
     "@types/mkdirp": "^1.0.2",
     "@types/mocha": "^10.0.10",
     "@types/node": "^14.18.63",
@@ -72,12 +72,12 @@
     "@types/traverse": "^0.6.37",
     "chai": "^4.5.0",
     "eslint": "^8.57.1",
-    "eslint-config-oclif": "^6.0.15",
+    "eslint-config-oclif": "^6.0.62",
     "eslint-config-oclif-typescript": "^3.1.14",
     "fancy-test": "^2.0.42",
     "mocha": "10.8.2",
     "nyc": "^15.1.0",
-    "sinon": "^19.0.2",
+    "sinon": "^19.0.5",
     "ts-node": "^10.9.2",
     "typescript": "^4.9.5"
   }