@sap/cli-core 2025.16.0 → 2025.19.0

package/logger/utils.js

@@ -1,12 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.logVerbose = void 0;
-const constants_1 = require("../constants");
-const options_1 = require("../utils/options");
-const logVerbose = (logger, ...args) => {
-    const verbose = (0, options_1.getOptionValueFromConfigGracefully)(constants_1.OPTION_VERBOSE);
+import { OPTION_VERBOSE } from "../constants.js";
+import { getOptionValueFromConfigGracefully } from "../utils/options.js";
+export const logVerbose = (logger, ...args) => {
+    const verbose = getOptionValueFromConfigGracefully(OPTION_VERBOSE);
     if (verbose) {
         logger.output(...args);
     }
 };
-exports.logVerbose = logVerbose;

package/module.d.ts

@@ -1,4 +1,4 @@
-import { PasscodeFunction } from "./commands/handler/authentication/passcode/types";
-import { Configuration as LoggerConfiguration } from "./logger";
-export { getCommands } from "./dwc/dwc";
+import { PasscodeFunction } from "./commands/handler/authentication/passcode/types.js";
+import { Configuration as LoggerConfiguration } from "./logger/index.js";
+export { getCommands } from "./dwc/dwc.js";
 export declare const configure: (logger?: LoggerConfiguration, passcodeFunction?: PasscodeFunction) => void;

package/module.js

@@ -1,57 +1,19 @@
-"use strict";
 /* eslint-disable import/first */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.configure = exports.getCommands = void 0;
-const dotenv = __importStar(require("dotenv"));
-const configureLoggers_1 = require("./configureLoggers");
+import * as dotenv from "dotenv";
+import { configureLoggers } from "./configureLoggers.js";
 dotenv.config({
     quiet: true, // default is false, but we want to avoid logging to the stdout
 });
-(0, configureLoggers_1.configureLoggers)();
-const config_1 = require("./config");
-const constants_1 = require("./constants");
-const logger_1 = require("./logger");
-var dwc_1 = require("./dwc/dwc");
-Object.defineProperty(exports, "getCommands", { enumerable: true, get: function () { return dwc_1.getCommands; } });
-const configure = (logger, passcodeFunction) => {
+configureLoggers();
+import { set } from "./config/index.js";
+import { CONFIG_PASSCODE_FUNCTION } from "./constants.js";
+import { configure as configureLogger, } from "./logger/index.js";
+export { getCommands } from "./dwc/dwc.js";
+export const configure = (logger, passcodeFunction) => {
     if (logger) {
-        (0, logger_1.configure)(logger);
+        configureLogger(logger);
     }
     if (passcodeFunction) {
-        (0, config_1.set)({ [constants_1.CONFIG_PASSCODE_FUNCTION]: passcodeFunction });
+        set({ [CONFIG_PASSCODE_FUNCTION]: passcodeFunction });
     }
 };
-exports.configure = configure;

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@sap/cli-core",
-  "version": "2025.16.0",
+  "version": "2025.19.0",
   "description": "Command-Line Interface (CLI) Core Module",
   "license": "SEE LICENSE IN LICENSE",
   "author": "SAP SE",
+  "type": "module",
   "homepage": "https://www.sap.com",
   "main": "index.js",
   "engines": {
-    "node": "^18 || ^19 || ^20 || ^21 || ^22",
+    "node": "^20 || ^21 || ^22",
     "npm": "^9 || ^10"
   },
   "keywords": [
@@ -18,16 +19,17 @@
   ],
   "dependencies": {
     "ajv": "8.17.1",
-    "axios": "1.10.0",
+    "axios": "1.11.0",
     "commander": "12.1.0",
     "compare-versions": "6.1.1",
-    "config": "4.0.1",
-    "dotenv": "17.2.0",
+    "config": "4.1.1",
+    "dotenv": "17.2.1",
     "form-data": "4.0.4",
-    "fs-extra": "11.3.0",
+    "fs-extra": "11.3.1",
     "https": "1.0.0",
     "https-proxy-agent": "7.0.6",
-    "lodash": "4.17.21",
+    "jszip": "3.10.1",
+    "lodash-es": "4.17.21",
     "open": "10.2.0",
     "path": "0.12.7",
     "prompts": "2.4.2",

package/result/ResultHandlerFactory.d.ts

@@ -1,4 +1,4 @@
-import { ResultHandler } from "./types";
+import { ResultHandler } from "./types.js";
 export declare class ResultHandlerFactory {
     private static INSTANCE;
     static get(): ResultHandler;

package/result/ResultHandlerFactory.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResultHandlerFactory = void 0;
-class ResultHandlerFactory {
+export class ResultHandlerFactory {
     static INSTANCE;
     static get() {
         return ResultHandlerFactory.INSTANCE;
@@ -10,4 +7,3 @@ class ResultHandlerFactory {
         ResultHandlerFactory.INSTANCE = instance;
     }
 }
-exports.ResultHandlerFactory = ResultHandlerFactory;

package/result/ResultHandlerImpl.d.ts

@@ -1,4 +1,4 @@
-import { ResultHandler } from "./types";
+import { ResultHandler } from "./types.js";
 export declare class ResultHandlerImpl implements ResultHandler {
     private data;
     setResult(data: any): void;

package/result/ResultHandlerImpl.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResultHandlerImpl = void 0;
-class ResultHandlerImpl {
+export class ResultHandlerImpl {
     data;
     setResult(data) {
         this.data = data;
@@ -10,4 +7,3 @@ class ResultHandlerImpl {
         return this.data;
     }
 }
-exports.ResultHandlerImpl = ResultHandlerImpl;

package/result/types.js

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

package/settings/index.d.ts

@@ -1,4 +1,4 @@
-import { KeyValuePair } from "../types";
+import { KeyValuePair } from "../types.js";
 export declare const get: () => Promise<KeyValuePair>;
 export declare const set: (key: string, value: string) => Promise<void>;
 export declare const remove: (key: string) => Promise<void>;

package/settings/index.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.remove = exports.set = exports.get = void 0;
-const cache_1 = require("../cache");
-const logger_1 = require("../logger");
+import { readFile, writeFile } from "../cache/index.js";
+import { get as getLoggerOrig } from "../logger/index.js";
 const SETTINGS_FILE = "settings.json";
-const getLogger = () => (0, logger_1.get)("settings");
-const get = async () => {
+const getLogger = () => getLoggerOrig("settings");
+export const get = async () => {
     try {
-        return JSON.parse(await (0, cache_1.readFile)(SETTINGS_FILE));
+        return JSON.parse(await readFile(SETTINGS_FILE));
     }
     catch (err) {
         const { debug } = getLogger();
@@ -15,20 +12,17 @@ const get = async () => {
         return {};
     }
 };
-exports.get = get;
-const set = async (key, value) => {
-    const settings = await (0, exports.get)();
+export const set = async (key, value) => {
+    const settings = await get();
     settings[key] = value;
-    await (0, cache_1.writeFile)(SETTINGS_FILE, JSON.stringify(settings));
+    await writeFile(SETTINGS_FILE, JSON.stringify(settings));
     const { debug } = getLogger();
     debug(`updated key ${key}, value ${value}`);
 };
-exports.set = set;
-const remove = async (key) => {
-    const settings = await (0, exports.get)();
+export const remove = async (key) => {
+    const settings = await get();
     delete settings[key];
-    await (0, cache_1.writeFile)(SETTINGS_FILE, JSON.stringify(settings));
+    await writeFile(SETTINGS_FILE, JSON.stringify(settings));
     const { debug } = getLogger();
     debug(`removed key ${key}`);
 };
-exports.remove = remove;

package/types.d.ts

@@ -19,7 +19,7 @@ export type Secret = {
     authorization_flow: GrantType;
 };
 export declare const ALLOWED_SECRET_TYPES: string[];
-export { HTTPMethod, HTTPConfig, HTTPResponse };
+export type { HTTPMethod, HTTPConfig, HTTPResponse };
 export type In = "query" | "body" | "header" | "path";
 export type DataType = "boolean" | "string" | "number";
 export type ParameterMapping = {

package/types.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GrantType = exports.CHARACTERS = exports.LogLevel = exports.ALLOWED_SECRET_TYPES = void 0;
 // unfortunately there does not seem to be a good solution to automatically
 // create the below array from a statically defined type. Thus, the array must
 // always be kept in sync with the type Secret defined above.
-exports.ALLOWED_SECRET_TYPES = [
+export const ALLOWED_SECRET_TYPES = [
     "id",
     "tenantUrl",
     "customClient",
@@ -22,7 +19,7 @@ exports.ALLOWED_SECRET_TYPES = [
     "id_token",
     "authorization_flow",
 ];
-var LogLevel;
+export var LogLevel;
 (function (LogLevel) {
     LogLevel[LogLevel["INACTIVE"] = 1] = "INACTIVE";
     LogLevel[LogLevel["ERROR"] = 2] = "ERROR";
@@ -30,9 +27,9 @@ var LogLevel;
     LogLevel[LogLevel["INFO"] = 4] = "INFO";
     LogLevel[LogLevel["DEBUG"] = 5] = "DEBUG";
     LogLevel[LogLevel["TRACE"] = 6] = "TRACE";
-})(LogLevel || (exports.LogLevel = LogLevel = {}));
+})(LogLevel || (LogLevel = {}));
 /* jscpd:ignore-start */
-exports.CHARACTERS = [
+export const CHARACTERS = [
     "a",
     "b",
     "c",
@@ -86,9 +83,9 @@ exports.CHARACTERS = [
     "Y",
     "Z",
 ];
-var GrantType;
+export var GrantType;
 (function (GrantType) {
     GrantType["authorization_code"] = "authorization_code";
     GrantType["client_credentials"] = "client_credentials";
     GrantType["refresh_token"] = "refresh_token";
-})(GrantType || (exports.GrantType = GrantType = {}));
+})(GrantType || (GrantType = {}));

package/utils/commands.d.ts

@@ -1,9 +1,9 @@
-import commander, { Command, Option } from "commander";
-import { Command as CommandType, Option as OptionType } from "../types";
+import { Command, Option } from "commander";
+import { Command as CommandType, Option as OptionType } from "../types.js";
 export declare const createCommand: (name?: string) => Command;
 export declare function getAbsoluteCommandName(command: Command): string;
 export declare const getShortFlagForLongName: (command: Command, option: OptionType) => string;
 export declare const isOptionAlreadyRegistered: ({ longName }: OptionType, command: Command) => boolean;
 export declare const registerLongName: (command: Command, option: OptionType) => string;
 export declare const buildOption: (command: Command, option: OptionType) => Promise<Option>;
-export declare const buildCommand: (topCommand: commander.Command, command: CommandType) => Promise<commander.Command>;
+export declare const buildCommand: (topCommand: Command, command: CommandType) => Promise<Command>;

package/utils/commands.js

@@ -1,17 +1,10 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildCommand = exports.buildOption = exports.registerLongName = exports.isOptionAlreadyRegistered = exports.getShortFlagForLongName = exports.createCommand = void 0;
-exports.getAbsoluteCommandName = getAbsoluteCommandName;
-const commander_1 = require("commander");
-const lodash_1 = __importDefault(require("lodash"));
-const types_1 = require("../types");
-const root_1 = require("../commands/handler/root");
-const logger_1 = require("../logger");
+import { Command, Option } from "commander";
+import { uniq } from "lodash-es";
+import { CHARACTERS, } from "../types.js";
+import { create as createRootHandler } from "../commands/handler/root/index.js";
+import { get } from "../logger/index.js";
 const registeredOptions = {};
-const getLogger = () => (0, logger_1.get)("utils.commands");
+const getLogger = () => get("utils.commands");
 const checkEmpty = (name, value) => {
     if (value.trim() === "") {
         throw new Error(`missing value for parameter ${name}`);
@@ -29,23 +22,22 @@ const checkCommand = (command) => {
         throw err;
     }
 };
-const createCommand = (name) => {
+export const createCommand = (name) => {
     const { output } = getLogger();
-    const command = new commander_1.Command(name);
+    const command = new Command(name);
     command.enablePositionalOptions();
     command.exitOverride();
     command.configureOutput({ writeErr: output, writeOut: output });
     command.allowUnknownOption();
     return command;
 };
-exports.createCommand = createCommand;
-function getAbsoluteCommandName(command) {
+export function getAbsoluteCommandName(command) {
     if (!command.parent) {
         return command.name();
     }
     return `${getAbsoluteCommandName(command.parent)}.${command.name()}`;
 }
-const getShortFlagForLongName = (command, option) => {
+export const getShortFlagForLongName = (command, option) => {
     const commandName = getAbsoluteCommandName(command);
     for (const s of Object.keys(registeredOptions[commandName] ?? {})) {
         if (registeredOptions[commandName][s] === option.longName) {
@@ -54,12 +46,10 @@ const getShortFlagForLongName = (command, option) => {
     }
     throw new Error(`no short flag registered for command ${commandName}, long name ${option.longName}`);
 };
-exports.getShortFlagForLongName = getShortFlagForLongName;
-const isOptionAlreadyRegistered = ({ longName }, command) => {
+export const isOptionAlreadyRegistered = ({ longName }, command) => {
     const opts = command.options?.map((o) => o.long?.replace("--", ""));
     return !!opts?.includes(longName);
 };
-exports.isOptionAlreadyRegistered = isOptionAlreadyRegistered;
 function shortFlagFromAnyCommand(optionLongName) {
     let shortFlag;
     Object.keys(registeredOptions).find((c) => {
@@ -69,7 +59,7 @@ function shortFlagFromAnyCommand(optionLongName) {
     return shortFlag;
 }
 function removeUsedShortFlags(possibleShortFlags) {
-    const usedShortFlags = lodash_1.default.uniq(Object.keys(registeredOptions).reduce((p1, c1) => {
+    const usedShortFlags = uniq(Object.keys(registeredOptions).reduce((p1, c1) => {
         return p1.concat(Object.keys(registeredOptions[c1]));
     }, []));
     return possibleShortFlags.filter((s) => !usedShortFlags.includes(s));
@@ -80,12 +70,12 @@ const getInitialShortFlagOptions = (option) => {
         option.longName[0].toUpperCase() === option.longName[0]
             ? option.longName[0].toLowerCase()
             : option.longName[0].toUpperCase(),
-        ...types_1.CHARACTERS,
+        ...CHARACTERS,
     ];
 };
-const registerLongName = (command, option) => {
+export const registerLongName = (command, option) => {
     try {
-        return (0, exports.getShortFlagForLongName)(command, option);
+        return getShortFlagForLongName(command, option);
     }
     catch (err) {
         let possibleShortFlags = getInitialShortFlagOptions(option);
@@ -110,10 +100,9 @@ const registerLongName = (command, option) => {
         throw new Error(`no short flag found for name ${option.longName}, command ${commandName}`);
     }
 };
-exports.registerLongName = registerLongName;
-const buildOption = async (command, option) => {
+export const buildOption = async (command, option) => {
     const mandatory = !!option.required;
-    const shortFlag = (0, exports.registerLongName)(command, option);
+    const shortFlag = registerLongName(command, option);
     let newDescr = option.description;
     if (!mandatory) {
         newDescr = newDescr ? `${newDescr} (optional)` : "(optional)";
@@ -121,7 +110,7 @@ const buildOption = async (command, option) => {
     const argStr = option.args
         ? option.args.reduce((p, c) => (c.optional ? `${p} [${c.name}]` : `${p} <${c.name}>`), "")
         : "";
-    const cOption = new commander_1.Option(`-${shortFlag}, --${option.longName}${argStr}`, newDescr)
+    const cOption = new Option(`-${shortFlag}, --${option.longName}${argStr}`, newDescr)
         .makeOptionMandatory(mandatory)
         .hideHelp(!!option.hidden);
     if (option.default) {
@@ -142,25 +131,24 @@ const buildOption = async (command, option) => {
     }
     return cOption;
 };
-exports.buildOption = buildOption;
-const buildCommand = async (topCommand, command) => {
+export const buildCommand = async (topCommand, command) => {
     []
         .concat([command], command.type === "topCommand" ? command.subCommands : [])
         .forEach((c) => checkCommand(c));
     const { command: name, description, options } = command;
-    const comm = (0, exports.createCommand)(name);
+    const comm = createCommand(name);
     topCommand.addCommand(comm);
     comm.description(description);
     comm.enablePositionalOptions();
     for (const option of options ?? []) {
         // eslint-disable-next-line no-await-in-loop
-        comm.addOption(await (0, exports.buildOption)(comm, option));
+        comm.addOption(await buildOption(comm, option));
     }
     if (command.type === "topCommand") {
         const { subCommands } = command;
         for (const subCommand of subCommands) {
             // eslint-disable-next-line no-await-in-loop
-            await (0, exports.buildCommand)(comm, subCommand);
+            await buildCommand(comm, subCommand);
         }
     }
     else {
@@ -169,9 +157,8 @@ const buildCommand = async (topCommand, command) => {
         if (args) {
             args.forEach((a) => comm.argument(`<${a.argument}>`, a.description));
         }
-        const rootHandler = await (0, root_1.create)(command, `Failed to ${command.description}`)(comm);
+        const rootHandler = await createRootHandler(command, `Failed to ${command.description}`)(comm);
         comm.action(rootHandler);
     }
     return comm;
 };
-exports.buildCommand = buildCommand;

package/utils/http/httpsAgent.d.ts

@@ -0,0 +1,6 @@
+import https from "https";
+import tls from "tls";
+export declare const getTlsVersion: () => tls.SecureVersion;
+export declare const isLegacyTlsDetectionEnabled: () => boolean;
+export declare const createTlsAgentOptions: () => https.AgentOptions;
+export declare const createHttpsAgent: (proxy?: string) => https.Agent;

package/utils/http/httpsAgent.js

@@ -0,0 +1,44 @@
+import https from "https";
+import { HttpsProxyAgent } from "https-proxy-agent";
+import { DEFAULT_TLS_VERSION, OPTION_TLS_VERSION } from "../../constants.js";
+import { get } from "../../logger/index.js";
+import { getOptionValueFromConfig } from "../options.js";
+const getLogger = () => get("http");
+export const getTlsVersion = () => {
+    return getOptionValueFromConfig(OPTION_TLS_VERSION, DEFAULT_TLS_VERSION);
+};
+export const isLegacyTlsDetectionEnabled = () => {
+    return process.env.CLI_LEGACY_TLS_DETECTION === "true";
+};
+export const createTlsAgentOptions = () => {
+    const { debug } = getLogger();
+    if (isLegacyTlsDetectionEnabled()) {
+        debug("using legacy TLS detection - letting Node.js decide default TLS version");
+        return {
+            rejectUnauthorized: true,
+        };
+    }
+    const tlsVersion = getTlsVersion();
+    debug(`configuring HTTPS agent with TLS version: ${tlsVersion}`);
+    const agentOptions = {
+        minVersion: tlsVersion,
+        maxVersion: tlsVersion,
+        rejectUnauthorized: true,
+    };
+    debug("HTTPS agent options:", JSON.stringify(agentOptions, null, 2));
+    return agentOptions;
+};
+export const createHttpsAgent = (proxy) => {
+    const { debug } = getLogger();
+    const agentOptions = createTlsAgentOptions();
+    let agent;
+    if (proxy) {
+        agent = new HttpsProxyAgent(proxy, agentOptions);
+        debug(`created HttpsProxyAgent with proxy: ${proxy}`);
+    }
+    else {
+        agent = new https.Agent(agentOptions);
+        debug("created https.Agent with TLS configuration");
+    }
+    return agent;
+};

package/utils/http/index.d.ts

@@ -1,4 +1,4 @@
-import { HTTPConfig, HTTPResponse } from "../../types";
+import { HTTPConfig, HTTPResponse } from "../../types.js";
 export declare const DEFAULTS: {
     maxBodyLength: number;
     maxContentLength: number;

package/utils/http/index.js

@@ -1,67 +1,64 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetch = exports.DEFAULTS = void 0;
-const axios_1 = __importDefault(require("axios"));
-const https_proxy_agent_1 = require("https-proxy-agent");
-const config_1 = require("../../config");
-const logger_1 = require("../../logger");
-const constants_1 = require("../../constants");
-const utils_1 = require("./utils");
-const core_1 = require("../../config/core");
-const utils_2 = require("../../logger/utils");
-exports.DEFAULTS = {
+import axios from "axios";
+import { getPackageName, getVersion } from "../../config/core.js";
+import { get as getConfig, set as setConfig } from "../../config/index.js";
+import { X_CSRF_TOKEN } from "../../constants.js";
+import { get } from "../../logger/index.js";
+import { logVerbose } from "../../logger/utils.js";
+import { createHttpsAgent, getTlsVersion, isLegacyTlsDetectionEnabled, } from "./httpsAgent.js";
+import { printCorrelationId, printError } from "./utils.js";
+export const DEFAULTS = {
     maxBodyLength: -1,
     maxContentLength: -1,
     maxRedirects: 0, // must be set to 0 because maxBodyLength: -1 won't work otherwise, see github.com/axios/axios/issues/4263,
 };
 const HEADERS_ETAG = "x-sap-cli-core-discovery-etag";
-const getLogger = () => (0, logger_1.get)("http");
-const HTTPS_PROXY = process.env.https_proxy ?? process.env.HTTPS_PROXY;
+const getLogger = () => get("http");
 const setEtag = (headers) => {
     const { debug } = getLogger();
     if (headers?.[HEADERS_ETAG]) {
-        (0, config_1.set)({ etag: headers[HEADERS_ETAG] });
+        setConfig({ etag: headers[HEADERS_ETAG] });
     }
     else {
         debug("header %s is not available", HEADERS_ETAG);
     }
 };
 const getCsrfTokenFromConfig = () => {
-    const cnfg = (0, config_1.get)();
-    return cnfg[constants_1.X_CSRF_TOKEN] ? { [constants_1.X_CSRF_TOKEN]: cnfg[constants_1.X_CSRF_TOKEN] } : {};
+    const cnfg = getConfig();
+    return cnfg[X_CSRF_TOKEN] ? { [X_CSRF_TOKEN]: cnfg[X_CSRF_TOKEN] } : {};
 };
-const fetch = async (config) => {
-    const cnfg = (0, config_1.get)();
+export const fetch = async (config) => {
+    const cnfg = getConfig();
     const logger = getLogger();
-    const { debug, output, trace, error } = logger;
+    const { debug, trace, error } = logger;
     try {
-        (0, utils_2.logVerbose)(logger, "%s %s", config.method.toUpperCase(), config.url);
+        logVerbose(logger, "%s %s", config.method.toUpperCase(), config.url);
         debug("http config: %s", JSON.stringify(config));
-        const httpsAgent = HTTPS_PROXY ? new https_proxy_agent_1.HttpsProxyAgent(HTTPS_PROXY) : null;
-        if (httpsAgent && cnfg.verbose) {
-            output(`using https proxy agent for https proxy`);
+        const HTTPS_PROXY = process.env.https_proxy ?? process.env.HTTPS_PROXY;
+        const httpsAgent = createHttpsAgent(HTTPS_PROXY);
+        if (HTTPS_PROXY) {
+            logVerbose(logger, "using https proxy agent for https proxy");
             debug(`using https proxy agent for https proxy ${HTTPS_PROXY}`);
         }
         else {
             debug("no https proxy defined via environment variable https_proxy");
         }
-        const res = await (0, axios_1.default)({
+        const tlsVersion = getTlsVersion();
+        const useLegacyTls = isLegacyTlsDetectionEnabled();
+        debug(`TLS configuration - version: ${tlsVersion}, legacy detection: ${useLegacyTls}`);
+        const res = await axios({
             httpsAgent,
             proxy: false,
             ...config,
-            ...exports.DEFAULTS,
+            ...DEFAULTS,
             headers: {
                 ...getCsrfTokenFromConfig(),
                 ...config.headers,
-                "User-Agent": `${(0, core_1.getPackageName)()}+${(0, core_1.getVersion)()}`,
+                "User-Agent": `${getPackageName()}+${getVersion()}`,
             },
         });
         if (cnfg.verbose) {
-            (0, utils_2.logVerbose)(logger, "%d %s", res.status, res.statusText);
-            (0, utils_1.printCorrelationId)(res);
+            logVerbose(logger, "%d %s", res.status, res.statusText);
+            printCorrelationId(res);
         }
         trace("response", res);
         setEtag(res.headers);
@@ -70,11 +67,10 @@ const fetch = async (config) => {
     catch (err) {
         error("error while executing http request", err.toString(), err.response);
         if (cnfg.verbose) {
-            (0, utils_1.printError)(err);
-            (0, utils_1.printCorrelationId)(err.response);
+            printError(err);
+            printCorrelationId(err.response);
         }
         setEtag(err.response?.headers);
         throw err;
     }
 };
-exports.fetch = fetch;

package/utils/http/utils.d.ts

@@ -1,4 +1,4 @@
-import { HTTPResponse } from "../../types";
+import { HTTPResponse } from "../../types.js";
 export declare const printCorrelationId: (response: HTTPResponse | undefined) => void;
 export declare const printError: (err: {
     response?: HTTPResponse;