@contentstack/cli-utilities 1.12.1 → 1.13.0

package/lib/config-handler.d.ts

@@ -1,23 +1,8 @@
 import Conf from 'conf';
-declare class Config {
-    private config;
-    constructor();
-    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;
-    private getObfuscationKey;
-    private getConfigDataAndUnlinkConfigFile;
-    private getEncryptedConfig;
-    private getDecryptedConfig;
-    get(key: any): string | any;
-    set(key: any, value: any): Conf<Record<string, unknown>>;
-    delete(key: any): Conf<Record<string, unknown>>;
+declare const lazyConfig: {
+    get(key: string): any;
+    set(key: string, value: any): Conf<Record<string, unknown>>;
+    delete(key: string): Conf<Record<string, unknown>>;
     clear(): void;
-}
-declare const _default: Config;
-export default _default;
+};
+export default lazyConfig;

package/lib/config-handler.js

@@ -206,4 +206,35 @@ class Config {
         (_a = this.config) === null || _a === void 0 ? void 0 : _a.clear();
     }
 }
-exports.default = new Config();
+let configInstance = null;
+function createConfigInstance() {
+    return new Config();
+}
+function getConfigInstance() {
+    if (!configInstance) {
+        configInstance = createConfigInstance();
+    }
+    return configInstance;
+}
+// Sinon based lazy config object
+const lazyConfig = {
+    // false positive - no hardcoded secret here
+    // @ts-ignore-next-line secret-detection
+    get(key) {
+        return getConfigInstance().get(key);
+    },
+    // false positive - no hardcoded secret here
+    // @ts-ignore-next-line secret-detection
+    set(key, value) {
+        return getConfigInstance().set(key, value);
+    },
+    // false positive - no hardcoded secret here
+    // @ts-ignore-next-line secret-detection
+    delete(key) {
+        return getConfigInstance().delete(key);
+    },
+    clear() {
+        return getConfigInstance().clear();
+    },
+};
+exports.default = lazyConfig;

package/lib/constants/errorTypes.d.ts

@@ -7,4 +7,7 @@ export declare const ERROR_TYPES: {
     readonly API_RESPONSE: "API_RESPONSE_DATA";
     readonly API_ERROR: "API_ERROR";
     readonly SERVER_ERROR: "SERVER_ERROR";
+    readonly INFORMATIONAL: "INFORMATIONAL_ERROR";
+    readonly REDIRECTION: "REDIRECTION_ERROR";
+    readonly SUCCESS: "SUCCESS";
 };

package/lib/constants/errorTypes.js

@@ -10,4 +10,7 @@ exports.ERROR_TYPES = {
     API_RESPONSE: 'API_RESPONSE_DATA',
     API_ERROR: 'API_ERROR',
     SERVER_ERROR: 'SERVER_ERROR',
+    INFORMATIONAL: 'INFORMATIONAL_ERROR',
+    REDIRECTION: 'REDIRECTION_ERROR',
+    SUCCESS: 'SUCCESS',
 };

package/lib/constants/logging.js

@@ -14,6 +14,6 @@ exports.levelColors = {
     error: 'red',
     warn: 'yellow',
     success: 'green',
-    info: 'blue',
-    debug: 'white'
+    info: 'white',
+    debug: 'blue'
 };

package/lib/helpers.js

@@ -86,6 +86,7 @@ const validateRegex = (str) => {
 };
 exports.validateRegex = validateRegex;
 const formatError = function (error) {
+    var _a, _b, _c, _d, _e;
     let parsedError;
     // Parse the error
     try {
@@ -102,9 +103,31 @@ const formatError = function (error) {
     catch (e) {
         parsedError = error;
     }
-    // Check if parsedError is an empty object
     if (parsedError && typeof parsedError === 'object' && Object.keys(parsedError).length === 0) {
-        return `An unknown error occurred. ${error}`;
+        if (!parsedError.message &&
+            !parsedError.code &&
+            !parsedError.status &&
+            !parsedError.errorMessage &&
+            !parsedError.error_message) {
+            return `An unknown error occurred. ${error}`;
+        }
+    }
+    if ((_b = (_a = parsedError === null || parsedError === void 0 ? void 0 : parsedError.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.errorMessage) {
+        return parsedError.response.data.errorMessage;
+    }
+    if (parsedError === null || parsedError === void 0 ? void 0 : parsedError.errorMessage) {
+        return parsedError.errorMessage;
+    }
+    const status = (parsedError === null || parsedError === void 0 ? void 0 : parsedError.status) || ((_c = parsedError === null || parsedError === void 0 ? void 0 : parsedError.response) === null || _c === void 0 ? void 0 : _c.status);
+    const errorCode = (parsedError === null || parsedError === void 0 ? void 0 : parsedError.errorCode) || ((_e = (_d = parsedError === null || parsedError === void 0 ? void 0 : parsedError.response) === null || _d === void 0 ? void 0 : _d.data) === null || _e === void 0 ? void 0 : _e.errorCode);
+    if (status === 422 && errorCode === 104) {
+        return 'Invalid email or password. Please check your credentials and try again.';
+    }
+    if (status === 401) {
+        return 'Authentication failed. Please check your credentials.';
+    }
+    if (status === 403) {
+        return 'Access denied. Please check your permissions.';
     }
     // Check for specific SSL error
     if ((parsedError === null || parsedError === void 0 ? void 0 : parsedError.code) === 'UNABLE_TO_GET_ISSUER_CERT_LOCALLY') {
@@ -114,6 +137,10 @@ const formatError = function (error) {
     if ((parsedError === null || parsedError === void 0 ? void 0 : parsedError.code) === 'SELF_SIGNED_CERT_IN_CHAIN') {
         return 'Self-signed certificate in the certificate chain! Please ensure your certificate configuration is correct and the necessary CA certificates are trusted.';
     }
+    // ENHANCED: Handle network errors with user-friendly messages
+    if (['ECONNREFUSED', 'ENOTFOUND', 'ETIMEDOUT', 'ENETUNREACH'].includes(parsedError === null || parsedError === void 0 ? void 0 : parsedError.code)) {
+        return `Connection failed: Unable to reach the server. Please check your internet connection.`;
+    }
     // Determine the error message
     let message = parsedError.errorMessage || parsedError.error_message || (parsedError === null || parsedError === void 0 ? void 0 : parsedError.code) || parsedError.message || parsedError;
     if (typeof message === 'object') {

package/lib/index.d.ts

@@ -24,3 +24,4 @@ export { FlagInput, ArgInput, FlagDefinition } from '@oclif/core/lib/interfaces/
 export { default as TablePrompt } from './inquirer-table-prompt';
 export { Logger };
 export { default as authenticationHandler } from './authentication-handler';
+export { v2Logger as log, cliErrorHandler, handleAndLogError, getLogPath } from './logger/log';

package/lib/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.authenticationHandler = exports.Logger = exports.TablePrompt = exports.execute = exports.ux = exports.flush = exports.settings = exports.toConfiguredId = exports.toStandardizedId = exports.run = exports.Plugin = exports.Parser = exports.Interfaces = exports.HelpBase = exports.Help = exports.loadHelpClass = exports.Flags = exports.Errors = exports.Config = exports.CommandHelp = exports.Args = exports.marketplaceSDKInitiator = exports.MarketplaceSDKInitiator = exports.marketplaceSDKClient = exports.CLITable = exports.Command = exports.flags = exports.args = exports.NodeCrypto = exports.printFlagDeprecation = exports.managementSDKInitiator = exports.managementSDKClient = exports.configHandler = exports.authHandler = exports.messageHandler = exports.CLIError = exports.cliux = exports.LoggerService = void 0;
+exports.getLogPath = exports.handleAndLogError = exports.cliErrorHandler = exports.log = exports.authenticationHandler = exports.Logger = exports.TablePrompt = exports.execute = exports.ux = exports.flush = exports.settings = exports.toConfiguredId = exports.toStandardizedId = exports.run = exports.Plugin = exports.Parser = exports.Interfaces = exports.HelpBase = exports.Help = exports.loadHelpClass = exports.Flags = exports.Errors = exports.Config = exports.CommandHelp = exports.Args = exports.marketplaceSDKInitiator = exports.MarketplaceSDKInitiator = exports.marketplaceSDKClient = exports.CLITable = exports.Command = exports.flags = exports.args = exports.NodeCrypto = exports.printFlagDeprecation = exports.managementSDKInitiator = exports.managementSDKClient = exports.configHandler = exports.authHandler = exports.messageHandler = exports.CLIError = exports.cliux = exports.LoggerService = void 0;
 const tslib_1 = require("tslib");
 const logger_1 = tslib_1.__importDefault(require("./logger"));
 exports.Logger = logger_1.default;
@@ -64,3 +64,8 @@ var inquirer_table_prompt_1 = require("./inquirer-table-prompt");
 Object.defineProperty(exports, "TablePrompt", { enumerable: true, get: function () { return tslib_1.__importDefault(inquirer_table_prompt_1).default; } });
 var authentication_handler_1 = require("./authentication-handler");
 Object.defineProperty(exports, "authenticationHandler", { enumerable: true, get: function () { return tslib_1.__importDefault(authentication_handler_1).default; } });
+var log_1 = require("./logger/log");
+Object.defineProperty(exports, "log", { enumerable: true, get: function () { return log_1.v2Logger; } });
+Object.defineProperty(exports, "cliErrorHandler", { enumerable: true, get: function () { return log_1.cliErrorHandler; } });
+Object.defineProperty(exports, "handleAndLogError", { enumerable: true, get: function () { return log_1.handleAndLogError; } });
+Object.defineProperty(exports, "getLogPath", { enumerable: true, get: function () { return log_1.getLogPath; } });

package/lib/interfaces/index.d.ts

@@ -74,7 +74,7 @@ export interface PrintOptions {
     bold?: boolean;
     color?: string;
 }
-export type LogType = 'info' | 'warn' | 'error' | 'debug';
+export type LogType = 'info' | 'warn' | 'error' | 'debug' | 'hidden' | 'success';
 export type LogsType = LogType | PrintOptions | undefined;
 export type MessageType = string | Error | Record<string, any> | Record<string, any>[];
 export type LogLevel = keyof typeof logLevels;
@@ -86,8 +86,9 @@ export type ClassifiedError = {
     meta?: Record<string, string | undefined>;
     context?: string;
     hidden?: boolean;
+    stackTrace?: Record<string, any>;
 };
-export type ErrorContext = {
+export interface ErrorContextBase {
     operation?: string;
     component?: string;
     userId?: string;
@@ -96,4 +97,7 @@ export type ErrorContext = {
     sessionId?: string;
     orgId?: string;
     apiKey?: string;
+}
+export type ErrorContext = ErrorContextBase & {
+    [key: string]: unknown;
 };

package/lib/logger/{cliErrorHandler.d.ts → cli-error-handler.d.ts}

@@ -19,7 +19,7 @@ import { ClassifiedError, ErrorContext } from '../interfaces';
  *
  * @example
  * ```typescript
- * const errorHandler = new CLIErrorHandler(true);
+ * const errorHandler = new CLIErrorHandler();
  *
  * try {
  *   // Some operation that may throw an error
@@ -35,30 +35,51 @@ import { ClassifiedError, ErrorContext } from '../interfaces';
  * @public
  */
 export default class CLIErrorHandler {
-    private isDebug;
-    constructor(isDebug?: boolean);
+    constructor();
     /**
      * 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.
+     * @param context - Optional additional context about the error.
+     * @param errMessage - Optional custom error message to override the default error message.
      *
-     * @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.
+     * @returns A `ClassifiedError` object containing essential error details in a clear,
+     *          concise format optimized for debugging.
+     */
+    classifyError(error: unknown, context?: ErrorContext, errMessage?: string): ClassifiedError;
+    /**
+     * Extracts a clear, concise error message from various error types.
+     */
+    private extractClearMessage;
+    /**
+     * Normalizes various error types into a standard Error object.
      *
-     * @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.
+     * @param error - The error to normalize
+     * @returns A normalized Error object
      */
-    classifyError(error: unknown, context?: ErrorContext): ClassifiedError;
     private normalizeToError;
-    private isApiError;
+    /**
+     * Determines the type of error based on its characteristics.
+     */
     private determineErrorType;
+    /**
+     * Extracts only essential error payload information for clear debugging.
+     */
     private extractErrorPayload;
-    private extractDebugPayload;
+    /**
+     * Extracts metadata from the error context and adds additional information.
+     *
+     * @param context - The error context to extract metadata from
+     * @param errorType - Optional error type to include in metadata
+     * @returns An object containing relevant metadata for debugging
+     */
     private extractMeta;
+    /**
+     * Checks if error contains sensitive information.
+     *
+     * @param error - Error to check
+     * @returns True if sensitive info is found
+     */
     private containsSensitiveInfo;
 }
 export { CLIErrorHandler };

package/lib/logger/cli-error-handler.js

@@ -0,0 +1,273 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLIErrorHandler = void 0;
+const helpers_1 = require("../helpers");
+const errorTypes_1 = require("../constants/errorTypes");
+const helpers_2 = require("../helpers");
+/**
+ * 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();
+ *
+ * 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() { }
+    /**
+     * 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.
+     * @param errMessage - Optional custom error message to override the default error message.
+     *
+     * @returns A `ClassifiedError` object containing essential error details in a clear,
+     *          concise format optimized for debugging.
+     */
+    classifyError(error, context, errMessage) {
+        try {
+            const normalized = this.normalizeToError(error);
+            const type = this.determineErrorType(normalized);
+            const hidden = this.containsSensitiveInfo(normalized);
+            const result = {
+                type,
+                message: errMessage || this.extractClearMessage(normalized),
+                error: this.extractErrorPayload(normalized),
+                meta: this.extractMeta(context, type),
+                hidden,
+            };
+            return result;
+        }
+        catch (e) {
+            return {
+                type: errorTypes_1.ERROR_TYPES.NORMALIZATION,
+                message: 'Failed to process error',
+                error: {
+                    originalError: String(e),
+                    errorType: typeof error,
+                },
+                meta: this.extractMeta(context, errorTypes_1.ERROR_TYPES.NORMALIZATION),
+                hidden: false,
+            };
+        }
+    }
+    /**
+     * Extracts a clear, concise error message from various error types.
+     */
+    extractClearMessage(error) {
+        var _a, _b;
+        if ((_b = (_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.errorMessage) {
+            return error.response.data.errorMessage;
+        }
+        if (error === null || error === void 0 ? void 0 : error.errorMessage) {
+            return error.errorMessage;
+        }
+        // Use existing formatError function for other cases
+        try {
+            const formattedMessage = (0, helpers_1.formatError)(error);
+            return formattedMessage || 'An error occurred. Please try again.';
+        }
+        catch (_c) {
+            return 'An error occurred. Please try again.';
+        }
+    }
+    /**
+     * Normalizes various error types into a standard Error object.
+     *
+     * @param error - The error to normalize
+     * @returns A normalized Error object
+     */
+    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 errorObj = error;
+                const message = errorObj.message || errorObj.error || errorObj.statusText || 'Unknown error';
+                const normalizedError = new Error(message);
+                // Only copy essential properties
+                const essentialProps = ['code', 'status', 'statusText', 'response', 'request', 'config'];
+                essentialProps.forEach((prop) => {
+                    if (errorObj[prop] !== undefined) {
+                        normalizedError[prop] = errorObj[prop];
+                    }
+                });
+                return normalizedError;
+            }
+            catch (_a) {
+                return new Error(JSON.stringify(error));
+            }
+        }
+        return new Error(String(error));
+    }
+    /**
+     * Determines the type of error based on its characteristics.
+     */
+    determineErrorType(error) {
+        const { status, code, name, response } = error;
+        const actualStatus = status || (response === null || response === void 0 ? void 0 : response.status);
+        // Network and timeout errors
+        if (['ECONNREFUSED', 'ENOTFOUND', 'ETIMEDOUT', 'ENETUNREACH'].includes(code)) {
+            return errorTypes_1.ERROR_TYPES.NETWORK;
+        }
+        // HTTP status-based classification
+        if (actualStatus) {
+            if (actualStatus >= 100 && actualStatus < 200)
+                return errorTypes_1.ERROR_TYPES.INFORMATIONAL;
+            if (actualStatus >= 300 && actualStatus < 400)
+                return errorTypes_1.ERROR_TYPES.REDIRECTION;
+            if (actualStatus >= 400 && actualStatus < 500)
+                return errorTypes_1.ERROR_TYPES.API_ERROR;
+            if (actualStatus >= 500)
+                return errorTypes_1.ERROR_TYPES.SERVER_ERROR;
+        }
+        // Specific error types
+        if (name === 'DatabaseError')
+            return errorTypes_1.ERROR_TYPES.DATABASE;
+        if (error.isAxiosError)
+            return errorTypes_1.ERROR_TYPES.NETWORK;
+        return errorTypes_1.ERROR_TYPES.APPLICATION;
+    }
+    /**
+     * Extracts only essential error payload information for clear debugging.
+     */
+    extractErrorPayload(error) {
+        var _a, _b;
+        const { name, message, code, status, response, request, config, statusText } = error;
+        const payload = {
+            name,
+            message: this.extractClearMessage(error),
+        };
+        // Add error identifiers
+        if (code)
+            payload.code = code;
+        if (status || (response === null || response === void 0 ? void 0 : response.status))
+            payload.status = status || (response === null || response === void 0 ? void 0 : response.status);
+        // Add request context with sensitive data redaction
+        if (request || config) {
+            const requestData = {
+                method: (request === null || request === void 0 ? void 0 : request.method) || (config === null || config === void 0 ? void 0 : config.method),
+                url: (request === null || request === void 0 ? void 0 : request.url) || (config === null || config === void 0 ? void 0 : config.url),
+                headers: (request === null || request === void 0 ? void 0 : request.headers) || (config === null || config === void 0 ? void 0 : config.headers),
+                data: (request === null || request === void 0 ? void 0 : request.data) || (config === null || config === void 0 ? void 0 : config.data),
+                timeout: config === null || config === void 0 ? void 0 : config.timeout,
+                baseURL: config === null || config === void 0 ? void 0 : config.baseURL,
+                params: config === null || config === void 0 ? void 0 : config.params,
+            };
+            // Use existing redactObject to mask sensitive data
+            payload.request = (0, helpers_2.redactObject)(requestData);
+        }
+        // Add response context with sensitive data redaction
+        if (response) {
+            const responseData = {
+                status,
+                statusText,
+                headers: response.headers,
+                data: response.data,
+            };
+            // Use existing redactObject to mask sensitive data
+            payload.response = (0, helpers_2.redactObject)(responseData);
+        }
+        // Extract user-friendly error message for API errors
+        if ((_a = response === null || response === void 0 ? void 0 : response.data) === null || _a === void 0 ? void 0 : _a.errorMessage) {
+            payload.userFriendlyMessage = response.data.errorMessage;
+        }
+        // Add stack trace only for non-API errors to avoid clutter
+        if (![errorTypes_1.ERROR_TYPES.API_ERROR, errorTypes_1.ERROR_TYPES.SERVER_ERROR].includes(this.determineErrorType(error))) {
+            payload.stack = (_b = error.stack) === null || _b === void 0 ? void 0 : _b.split('\n').slice(0, 5).join('\n');
+        }
+        return payload;
+    }
+    /**
+     * Extracts metadata from the error context and adds additional information.
+     *
+     * @param context - The error context to extract metadata from
+     * @param errorType - Optional error type to include in metadata
+     * @returns An object containing relevant metadata for debugging
+     */
+    extractMeta(context, errorType) {
+        if (!context)
+            return {};
+        const baseMeta = {};
+        if (context.operation)
+            baseMeta.operation = context.operation;
+        if (context.component)
+            baseMeta.component = context.component;
+        if (context.userId)
+            baseMeta.userId = context.userId;
+        if (context.sessionId)
+            baseMeta.sessionId = context.sessionId;
+        if (context.orgId)
+            baseMeta.orgId = context.orgId;
+        if (errorType)
+            baseMeta.errorType = errorType;
+        if (context.email)
+            baseMeta.email = context.email;
+        return baseMeta;
+    }
+    /**
+     * Checks if error contains sensitive information.
+     *
+     * @param error - Error to check
+     * @returns True if sensitive info is found
+     */
+    containsSensitiveInfo(error) {
+        try {
+            const content = `${error.message} ${error.stack || ''}`.toLowerCase();
+            const sensitiveTerms = [
+                'password',
+                'token',
+                'secret',
+                'credentials',
+                'api_key',
+                'api-key',
+                'authorization',
+                'sessionid',
+                'authtoken',
+                'x-api-key',
+                'tfa_token',
+                'otp',
+                'security_code',
+                'bearer',
+                'cookie',
+            ];
+            return sensitiveTerms.some((term) => content.includes(term));
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+}
+exports.default = CLIErrorHandler;
+exports.CLIErrorHandler = CLIErrorHandler;

package/lib/logger/log.d.ts

@@ -1,5 +1,5 @@
 import { default as Logger } from './logger';
-import { CLIErrorHandler } from './cliErrorHandler';
+import { CLIErrorHandler } from './cli-error-handler';
 import { ErrorContext } from '../interfaces';
 declare const v2Logger: Logger;
 declare const cliErrorHandler: CLIErrorHandler;
@@ -19,5 +19,6 @@ declare const cliErrorHandler: CLIErrorHandler;
  * - 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 };
+declare function handleAndLogError(error: unknown, context?: ErrorContext, errorMessage?: string): void;
+declare function getLogPath(): string;
+export { v2Logger, cliErrorHandler, handleAndLogError, getLogPath };

package/lib/logger/log.js

@@ -1,13 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleAndLogError = exports.cliErrorHandler = exports.v2Logger = void 0;
+exports.getLogPath = 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') });
+const cli_error_handler_1 = require("./cli-error-handler");
+const __1 = require("..");
+let loggerInstance = null;
+function createLoggerInstance() {
+    const config = {
+        basePath: getLogPath(),
+        logLevel: __1.configHandler.get('log.level') || 'info',
+    };
+    return new logger_1.default(config);
+}
+// Lazy proxy object that behaves like a Logger
+const v2Logger = new Proxy({}, {
+    get(_, prop) {
+        if (!loggerInstance) {
+            loggerInstance = createLoggerInstance();
+        }
+        const targetProp = loggerInstance[prop];
+        if (typeof targetProp === 'function') {
+            return targetProp.bind(loggerInstance);
+        }
+        return targetProp;
+    },
+});
 exports.v2Logger = v2Logger;
-const cliErrorHandler = new cliErrorHandler_1.CLIErrorHandler(true); // Enable debug mode for error classification
+const cliErrorHandler = new cli_error_handler_1.CLIErrorHandler(); // Enable debug mode for error classification
 exports.cliErrorHandler = cliErrorHandler;
 /**
  * Handles and logs an error by classifying it and logging the relevant details.
@@ -25,28 +46,21 @@ exports.cliErrorHandler = cliErrorHandler;
  * - 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);
+function handleAndLogError(error, context, errorMessage) {
+    var _a;
+    const classified = cliErrorHandler.classifyError(error, context, errorMessage);
     // Always log the error
     v2Logger.logError({
         type: classified.type,
-        message: classified.message,
+        message: errorMessage || ((_a = classified.error) === null || _a === void 0 ? void 0 : _a.message) || classified.message,
         error: classified.error,
-        context: classified.context,
+        context: typeof classified.context === 'string' ? { message: classified.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;
+function getLogPath() {
+    return process.env.CS_CLI_LOG_PATH || __1.configHandler.get('log.path') || path.join(__dirname, 'logs');
+}
+exports.getLogPath = getLogPath;

package/lib/logger/logger.d.ts

@@ -11,7 +11,6 @@ export default class Logger {
     private isSensitiveKey;
     private redactObject;
     private redact;
-    private isLogEntry;
     private shouldLog;
     error(message: string, meta?: any): void;
     warn(message: string, meta?: any): void;
@@ -22,7 +21,7 @@ export default class Logger {
         type: string;
         message: string;
         error: any;
-        context?: string;
+        context?: Record<string, any>;
         hidden?: boolean;
         meta?: Record<string, any>;
     }): void;
@@ -30,28 +29,28 @@ export default class Logger {
         type: string;
         message: string;
         warn?: any;
-        context?: string;
+        context?: Record<string, any>;
         meta?: Record<string, any>;
     }): void;
     logInfo(params: {
         type: string;
         message: string;
         info?: any;
-        context?: string;
+        context?: Record<string, any>;
         meta?: Record<string, any>;
     }): void;
     logSuccess(params: {
         type: string;
         message: string;
         data?: any;
-        context?: string;
+        context?: Record<string, any>;
         meta?: Record<string, any>;
     }): void;
     logDebug(params: {
         type: string;
         message: string;
         debug?: any;
-        context?: string;
+        context?: Record<string, any>;
         meta?: Record<string, any>;
     }): void;
 }

package/lib/logger/logger.js

@@ -18,8 +18,10 @@ class Logger {
             /management[-._]?token/i,
             /sessionid/i,
             /orgid/i,
+            /stack/i,
         ];
         this.config = config;
+        winston.addColors(logging_1.levelColors);
         this.loggers = {
             error: this.getLoggerInstance('error'),
             warn: this.getLoggerInstance('warn'),
@@ -30,10 +32,7 @@ class Logger {
     }
     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);
+        return this.createLogger(level === 'hidden' ? 'error' : level, filePath);
     }
     get loggerOptions() {
         return {
@@ -46,31 +45,23 @@ class Logger {
     createLogger(level, filePath) {
         return winston.createLogger({
             levels: logging_1.logLevels,
-            level: 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 redactedInfo = this.redact(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);
+                        const levelText = redactedInfo.level.toUpperCase();
+                        const { timestamp, message } = redactedInfo;
+                        return colorizer.colorize(redactedInfo.level, `[${timestamp}] ${levelText}: ${message}`);
                     })),
                 }),
             ],
         });
     }
     isSensitiveKey(keyStr) {
-        return keyStr && typeof keyStr === 'string'
-            ? this.sensitiveKeys.some((regex) => regex.test(keyStr))
-            : false;
+        return typeof keyStr === 'string' ? this.sensitiveKeys.some((regex) => regex.test(keyStr)) : false;
     }
     redactObject(obj) {
         const self = this;
@@ -89,43 +80,39 @@ class Logger {
                 this.redactObject(splat);
             return copy;
         }
-        catch (error) {
+        catch (_a) {
             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;
+        const minLevel = configLevel ? logging_1.logLevels[configLevel] : 2;
+        return logging_1.logLevels[level] <= minLevel;
     }
     /* === Public Log Methods === */
     error(message, meta) {
         if (this.shouldLog('error', 'console') || this.shouldLog('error', 'file')) {
-            this.loggers.error.error(message, meta);
+            this.loggers.error.error(message, Object.assign(Object.assign({}, meta), { level: 'error' }));
         }
     }
     warn(message, meta) {
         if (this.shouldLog('warn', 'console') || this.shouldLog('warn', 'file')) {
-            this.loggers.warn.warn(message, meta);
+            this.loggers.warn.warn(message, Object.assign(Object.assign({}, meta), { level: 'warn' }));
         }
     }
     info(message, meta) {
         if (this.shouldLog('info', 'console') || this.shouldLog('info', 'file')) {
-            this.loggers.info.info(message, meta);
+            this.loggers.info.info(message, Object.assign(Object.assign({}, meta), { level: 'info' }));
         }
     }
     success(message, meta) {
-        if (this.shouldLog('info', 'console') || this.shouldLog('info', 'file')) {
-            this.loggers.success.info(message, Object.assign(Object.assign({}, meta), { type: 'success' }));
+        if (this.shouldLog('success', 'console') || this.shouldLog('success', 'file')) {
+            this.loggers.success.log('success', message, Object.assign({}, meta));
         }
     }
     debug(message, meta) {
         if (this.shouldLog('debug', 'console') || this.shouldLog('debug', 'file')) {
-            this.loggers.debug.debug(message, meta);
+            this.loggers.debug.debug(message, Object.assign(Object.assign({}, meta), { level: 'debug' }));
         }
     }
     /* === Structured Logging === */
@@ -133,12 +120,16 @@ class Logger {
         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),
+            meta: Object.assign(Object.assign({ type: params.type, error: params.error }, (params.context || {})), (params.meta || {})),
         };
-        const targetLevel = params.hidden ? 'debug' : 'error';
-        if (this.shouldLog(targetLevel, 'console') || this.shouldLog(targetLevel, 'file')) {
-            this.loggers[targetLevel].error(logPayload);
+        // Always log to error file, but respect hidden parameter for console
+        if (this.shouldLog('error', 'file')) {
+            this.loggers.error.error(logPayload);
+        }
+        // For console, use debug level if hidden, otherwise error level
+        const consoleLevel = params.hidden ? 'debug' : 'error';
+        if (this.shouldLog(consoleLevel, 'console')) {
+            this.loggers[consoleLevel].error(logPayload);
         }
     }
     logWarn(params) {
@@ -146,7 +137,7 @@ class Logger {
             level: logging_1.logLevels.warn,
             message: params.message,
             timestamp: new Date(),
-            meta: Object.assign({ type: params.type, context: params.context }, params.meta),
+            meta: Object.assign(Object.assign({ type: params.type, warn: params.warn }, (params.context || {})), (params.meta || {})),
         };
         if (this.shouldLog('warn', 'console') || this.shouldLog('warn', 'file')) {
             this.loggers.warn.warn(logPayload);
@@ -157,7 +148,7 @@ class Logger {
             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),
+            meta: Object.assign(Object.assign({ type: params.type, info: params.info }, (params.context || {})), (params.meta || {})),
         };
         if (this.shouldLog('info', 'console') || this.shouldLog('info', 'file')) {
             this.loggers.info.info(logPayload);
@@ -165,21 +156,20 @@ class Logger {
     }
     logSuccess(params) {
         const logPayload = {
-            level: logging_1.logLevels.success,
+            level: 'success',
             message: params.message,
             timestamp: new Date(),
-            meta: Object.assign({ type: params.type, data: params.data, context: params.context }, params.meta),
+            meta: Object.assign(Object.assign({ type: params.type, data: params.data }, (params.context || {})), (params.meta || {})),
         };
-        if (this.shouldLog('info', 'console') || this.shouldLog('info', 'file')) {
-            this.loggers.success.info(logPayload);
+        if (this.shouldLog('success', 'console') || this.shouldLog('success', 'file')) {
+            this.loggers.success.log(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),
+            meta: Object.assign(Object.assign({ type: params.type, debug: params.debug }, (params.context || {})), (params.meta || {})),
         };
         if (this.shouldLog('debug', 'console') || this.shouldLog('debug', 'file')) {
             this.loggers.debug.debug(logPayload);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentstack/cli-utilities",
-  "version": "1.12.1",
+  "version": "1.13.0",
   "description": "Utilities for contentstack projects",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/lib/logger/cliErrorHandler.js

@@ -1,217 +0,0 @@
-"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;