@sap/cli-core 2023.12.0

package/commands/handler/force.d.ts

@@ -0,0 +1,2 @@
+import { Handler } from "../../types";
+export declare const create: (message: string) => Handler;

package/commands/handler/force.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const config_1 = require("../../config");
+const constants_1 = require("../../constants");
+const options_1 = require("./options");
+const PARAM_REGEX = /{.*}/;
+const replacer = (toBeReplaced) => {
+    const param = toBeReplaced.slice(1, -1);
+    return `{${lodash_1.default.kebabCase(param)}}`;
+};
+const create = (message) => (0, options_1.create)([
+    {
+        ...constants_1.OPTION_FORCE,
+        required: true,
+        prompts: {
+            type: "confirm",
+            initial: true,
+            message: () => {
+                const config = (0, config_1.get)();
+                let intMessage = message.replace(PARAM_REGEX, replacer);
+                Object.entries(config.options).forEach((option) => {
+                    intMessage = intMessage.replace(`{${option[0]}}`, option[1]);
+                });
+                return intMessage;
+            },
+            inputValidator: (value) => value,
+        },
+    },
+], undefined, false, true);
+exports.create = create;

package/commands/handler/index.d.ts

@@ -0,0 +1,18 @@
+export { create as createRootHandler } from "./root";
+export { create as createMandatoryOptionsHandler } from "./mandatoryOptions";
+export { create as createNextHandler } from "./next";
+export { create as createOrHandler } from "./or";
+export { create as createParseArgumentsHandler } from "./parseArguments";
+export { create as createAuthenticationHandler } from "./authentication";
+export { create as createPasscodeHandler } from "./authentication/passcode";
+export { create as createOauthHandler } from "./authentication/oauth";
+export { create as createForceHandler } from "./force";
+export { create as createFetchHandler } from "./fetch";
+export { create as createOptionsHandler } from "./options";
+export { create as createInputHandler } from "./input";
+export { create as createCheckOptionsExistence } from "./checkOptionsExistence";
+export { create as createFailHandler } from "./fail";
+export { create as createSucceedHandler } from "./succeed";
+export { create as createErrorHandler } from "./error";
+export { create as createResilientHandler } from "./resilient";
+export { create as createStackTraceHandler } from "./stackTrace";

package/commands/handler/index.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStackTraceHandler = exports.createResilientHandler = exports.createErrorHandler = exports.createSucceedHandler = exports.createFailHandler = exports.createCheckOptionsExistence = exports.createInputHandler = exports.createOptionsHandler = exports.createFetchHandler = exports.createForceHandler = exports.createOauthHandler = exports.createPasscodeHandler = exports.createAuthenticationHandler = exports.createParseArgumentsHandler = exports.createOrHandler = exports.createNextHandler = exports.createMandatoryOptionsHandler = exports.createRootHandler = void 0;
+var root_1 = require("./root");
+Object.defineProperty(exports, "createRootHandler", { enumerable: true, get: function () { return root_1.create; } });
+var mandatoryOptions_1 = require("./mandatoryOptions");
+Object.defineProperty(exports, "createMandatoryOptionsHandler", { enumerable: true, get: function () { return mandatoryOptions_1.create; } });
+var next_1 = require("./next");
+Object.defineProperty(exports, "createNextHandler", { enumerable: true, get: function () { return next_1.create; } });
+var or_1 = require("./or");
+Object.defineProperty(exports, "createOrHandler", { enumerable: true, get: function () { return or_1.create; } });
+var parseArguments_1 = require("./parseArguments");
+Object.defineProperty(exports, "createParseArgumentsHandler", { enumerable: true, get: function () { return parseArguments_1.create; } });
+var authentication_1 = require("./authentication");
+Object.defineProperty(exports, "createAuthenticationHandler", { enumerable: true, get: function () { return authentication_1.create; } });
+var passcode_1 = require("./authentication/passcode");
+Object.defineProperty(exports, "createPasscodeHandler", { enumerable: true, get: function () { return passcode_1.create; } });
+var oauth_1 = require("./authentication/oauth");
+Object.defineProperty(exports, "createOauthHandler", { enumerable: true, get: function () { return oauth_1.create; } });
+var force_1 = require("./force");
+Object.defineProperty(exports, "createForceHandler", { enumerable: true, get: function () { return force_1.create; } });
+var fetch_1 = require("./fetch");
+Object.defineProperty(exports, "createFetchHandler", { enumerable: true, get: function () { return fetch_1.create; } });
+var options_1 = require("./options");
+Object.defineProperty(exports, "createOptionsHandler", { enumerable: true, get: function () { return options_1.create; } });
+var input_1 = require("./input");
+Object.defineProperty(exports, "createInputHandler", { enumerable: true, get: function () { return input_1.create; } });
+var checkOptionsExistence_1 = require("./checkOptionsExistence");
+Object.defineProperty(exports, "createCheckOptionsExistence", { enumerable: true, get: function () { return checkOptionsExistence_1.create; } });
+var fail_1 = require("./fail");
+Object.defineProperty(exports, "createFailHandler", { enumerable: true, get: function () { return fail_1.create; } });
+var succeed_1 = require("./succeed");
+Object.defineProperty(exports, "createSucceedHandler", { enumerable: true, get: function () { return succeed_1.create; } });
+var error_1 = require("./error");
+Object.defineProperty(exports, "createErrorHandler", { enumerable: true, get: function () { return error_1.create; } });
+var resilient_1 = require("./resilient");
+Object.defineProperty(exports, "createResilientHandler", { enumerable: true, get: function () { return resilient_1.create; } });
+var stackTrace_1 = require("./stackTrace");
+Object.defineProperty(exports, "createStackTraceHandler", { enumerable: true, get: function () { return stackTrace_1.create; } });

package/commands/handler/input/file.d.ts

@@ -0,0 +1,2 @@
+import { Handler } from "../../../types";
+export declare const create: () => Handler;

package/commands/handler/input/file.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const config_1 = require("../../../config");
+const logger_1 = require("../../../logger");
+const constants_1 = require("../../../constants");
+const checkOptionsExistence_1 = require("../checkOptionsExistence");
+const next_1 = require("../next");
+const options_1 = require("../options");
+const readBodyFromFile = () => async () => {
+    const config = (0, config_1.get)();
+    const filePath = config.options[constants_1.OPTION_FILE_PATH.longName];
+    const { debug, trace } = (0, logger_1.get)("commands.handler.input.file");
+    debug("reading request body from %s", filePath);
+    try {
+        (0, config_1.set)({
+            data: JSON.parse(await fs_extra_1.default.readFile(filePath, "utf-8")),
+        });
+    }
+    catch (err) {
+        if (config.verbose) {
+            // eslint-disable-next-line
+            console.log(`Failed to read content from file ${filePath}. Does the file really exist and does it contain valid JSON?`);
+        }
+        trace(`Failed to read content from file ${filePath}`, err);
+        throw err;
+    }
+};
+const create = () => (0, next_1.create)((0, checkOptionsExistence_1.create)(constants_1.OPTION_INPUT), (0, options_1.create)(constants_1.OPTION_FILE_PATH, { readEnv: true, readFile: true, readOptions: true, readPipe: true }, true, true), readBodyFromFile);
+exports.create = create;

package/commands/handler/input/index.d.ts

@@ -0,0 +1,2 @@
+import { Handler } from "../../../types";
+export declare const create: () => Handler;

package/commands/handler/input/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const or_1 = require("../or");
+const input_1 = require("./input");
+const file_1 = require("./file");
+const create = () => (0, or_1.create)((0, file_1.create)(), (0, input_1.create)());
+exports.create = create;

package/commands/handler/input/input.d.ts

@@ -0,0 +1,2 @@
+import { Handler } from "../../../types";
+export declare const create: () => Handler;

package/commands/handler/input/input.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const prompts_1 = __importDefault(require("prompts"));
+const config_1 = require("../../../config");
+const constants_1 = require("../../../constants");
+const logger_1 = require("../../../logger");
+const commands_1 = require("../../../utils/commands");
+const create = () => (command) => {
+    command.addOption((0, commands_1.buildOption)(constants_1.OPTION_INPUT));
+    return async () => {
+        const config = (0, config_1.get)();
+        const { debug } = (0, logger_1.get)("handler.input.input");
+        if (config.options[constants_1.OPTION_FILE_PATH.longName]) {
+            throw new Error(`input provided through option --${constants_1.OPTION_FILE_PATH.longName}`);
+        }
+        let input = config.options[constants_1.OPTION_INPUT.longName];
+        if (!input) {
+            input = (await prompts_1.default.prompt({
+                type: "text",
+                message: `Please provide input as a string to use for the command:`,
+                name: "value",
+            })).value;
+        }
+        if (!input) {
+            throw new Error("no input");
+        }
+        debug("reading request body from data");
+        try {
+            (0, config_1.set)({ data: JSON.parse(input) });
+        }
+        catch (err) {
+            if (config.verbose) {
+                // eslint-disable-next-line
+                console.log("Failed to parse input data. Is it a valid escaped JSON string?");
+            }
+            throw err;
+        }
+    };
+};
+exports.create = create;

package/commands/handler/mandatoryOptions.d.ts

@@ -0,0 +1,2 @@
+import { Handler } from "../../types";
+export declare const create: () => Handler;

package/commands/handler/mandatoryOptions.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const config_1 = require("../../config");
+const constants_1 = require("../../constants");
+const utils_1 = require("../../utils/utils");
+const next_1 = require("./next");
+const options_1 = require("./options");
+const MANDATORY_OPTIONS = [
+    constants_1.OPTION_VERBOSE,
+    constants_1.OPTION_OPTIONS_FILE,
+    { ...constants_1.OPTION_HOST, required: true },
+];
+const post = () => async () => {
+    const config = (0, config_1.get)();
+    const tenant = (0, utils_1.parseTenant)(config.options[constants_1.OPTION_HOST.longName]);
+    const info = (0, utils_1.getInfoFromTenant)(tenant, config.verbose);
+    for (const [key, value] of Object.entries(info)) {
+        if (!config[key]) {
+            (0, config_1.set)({ [key]: value });
+        }
+    }
+};
+const create = () => (0, next_1.create)((0, options_1.create)(MANDATORY_OPTIONS), post);
+exports.create = create;

package/commands/handler/next.d.ts

@@ -0,0 +1,2 @@
+import { Handler } from "../../types";
+export declare const create: (...handlers: Array<Handler>) => Handler;

package/commands/handler/next.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const stackTrace_1 = require("./stackTrace");
+const nextHandler = (...handlers) => (command) => {
+    const commandHandlers = [];
+    for (const handler of handlers) {
+        commandHandlers.push(handler(command));
+    }
+    return async (...args) => {
+        for (const handler of commandHandlers) {
+            // eslint-disable-next-line
+            await handler(...args);
+        }
+    };
+};
+const create = (...handlers) => (0, stackTrace_1.create)(nextHandler(...handlers));
+exports.create = create;
+/* jscpd:ignore-end */

package/commands/handler/options/env.d.ts

@@ -0,0 +1,2 @@
+import { Handler, Option } from "../../../types";
+export declare const create: (option: Option) => Handler;

package/commands/handler/options/env.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const logger_1 = require("../../../logger");
+const utils_1 = require("../../../utils/utils");
+const utils_2 = require("./utils");
+/* jscpd:ignore-start */
+const create = (option) => () => async () => {
+    const { debug } = (0, logger_1.get)("commands.handler.options.env");
+    /* jscpd:ignore-end */
+    debug(`reading option ${option.longName} from env`);
+    if (!process.env[(0, utils_1.toConstantCase)(option.longName)]) {
+        throw new Error(`env variable process.env.${(0, utils_1.toConstantCase)(option.longName)} is not set`);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    (0, utils_2.setOption)(option, process.env[(0, utils_1.toConstantCase)(option.longName)]);
+};
+exports.create = create;

package/commands/handler/options/file.d.ts

@@ -0,0 +1,2 @@
+import { Handler, Option } from "../../../types";
+export declare const create: (option: Option) => Handler;

package/commands/handler/options/file.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const constants_1 = require("../../../constants");
+const logger_1 = require("../../../logger");
+const options_1 = require("../../../utils/options");
+const utils_1 = require("./utils");
+/* jscpd:ignore-start */
+const create = (option) => () => async () => {
+    const { debug, trace } = (0, logger_1.get)("commands.handler.options.file");
+    /* jscpd:ignore-end */
+    debug(`reading option ${option.longName} from file`);
+    const filePath = (0, options_1.getOptionValueFromConfig)(constants_1.OPTION_OPTIONS_FILE);
+    try {
+        (0, utils_1.setOption)(option, await (0, utils_1.getValueFromOptionsFile)(filePath, option));
+    }
+    catch (err) {
+        trace(`failed to read option ${option.longName} from options file ${filePath}`, err);
+    }
+};
+exports.create = create;

package/commands/handler/options/index.d.ts

@@ -0,0 +1,7 @@
+import { Handler, Option } from "../../../types";
+export declare const create: (options: Array<Option> | Option, { readPipe, readEnv, readFile, readOptions }?: {
+    readPipe: boolean;
+    readEnv: boolean;
+    readFile: boolean;
+    readOptions: boolean;
+}, promptAlways?: boolean, throwIfHandlersFailed?: boolean) => Handler;

package/commands/handler/options/index.js

@@ -0,0 +1,32 @@
+"use strict";
+/* eslint-disable no-await-in-loop */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const utils_1 = require("./utils");
+const or_1 = require("../or");
+const next_1 = require("../next");
+const checkOptionsExistence_1 = require("../checkOptionsExistence");
+const pipe_1 = require("./pipe");
+const file_1 = require("./file");
+const option_1 = require("./option");
+const succeed_1 = require("../succeed");
+const fail_1 = require("../fail");
+const env_1 = require("./env");
+const createHandler = (use, option, handler) => (0, next_1.create)((0, checkOptionsExistence_1.create)(option), use ? handler : (0, succeed_1.create)());
+const create = (options, { readPipe, readEnv, readFile, readOptions } = {
+    readPipe: true,
+    readEnv: true,
+    readFile: true,
+    readOptions: true,
+}, promptAlways = false, throwIfHandlersFailed = false) => (command) => {
+    const intOptions = Array.isArray(options) ? options : [options];
+    (0, utils_1.checkOptions)(intOptions, command);
+    return async () => {
+        for (const option of intOptions) {
+            await (0, or_1.create)((0, checkOptionsExistence_1.create)(option, false), (0, or_1.create)(createHandler(readPipe, option, (0, pipe_1.create)(option)), createHandler(readEnv, option, (0, env_1.create)(option)), createHandler(readFile, option, (0, file_1.create)(option)), createHandler(readOptions, option, (0, option_1.create)(option, promptAlways))), throwIfHandlersFailed
+                ? (0, fail_1.create)()
+                : (0, succeed_1.create)())(command)();
+        }
+    };
+};
+exports.create = create;

package/commands/handler/options/option.d.ts

@@ -0,0 +1,2 @@
+import { Handler, Option } from "../../../types";
+export declare const create: (option: Option, promptAlways?: boolean) => Handler;

package/commands/handler/options/option.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const logger_1 = require("../../../logger");
+const utils_1 = require("./utils");
+const create = (option, promptAlways = false) => () => async () => {
+    const { debug } = (0, logger_1.get)("commands.handler.options.option");
+    debug(`reading option ${option.longName} from options`);
+    if (option.required || promptAlways) {
+        if (!option.prompts) {
+            throw new Error(`inconsistent option ${option.longName}, no prompts configuration available`);
+        }
+        const value = await (0, utils_1.promptForValue)(option);
+        (0, utils_1.setOption)(option, value);
+    }
+    else {
+        throw new Error(`option ${option.longName} is not required and promptAlways is false`);
+    }
+};
+exports.create = create;

package/commands/handler/options/pipe.d.ts

@@ -0,0 +1,2 @@
+import { Handler, Option } from "../../../types";
+export declare const create: (option: Option) => Handler;

package/commands/handler/options/pipe.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const fs_extra_1 = require("fs-extra");
+const logger_1 = require("../../../logger");
+const utils_1 = require("./utils");
+const getLogger = () => (0, logger_1.get)("commands.handler.options.pipe");
+let data;
+const getDataFromPipe = () => {
+    if (data === undefined) {
+        try {
+            data = JSON.parse((0, fs_extra_1.readFileSync)(0, "utf-8"));
+        }
+        catch (err) {
+            const { error } = getLogger();
+            error("failed to read from pipe", err);
+            data = null;
+            return getDataFromPipe();
+        }
+    }
+    else if (data === null) {
+        throw new Error("no data received from pipe");
+    }
+    return data;
+};
+/* jscpd:ignore-start */
+const create = (option) => () => async () => {
+    const { debug } = getLogger();
+    /* jscpd:ignore-end */
+    debug(`reading option ${option.longName} from pipe`);
+    const options = getDataFromPipe();
+    (0, utils_1.setOption)(option, options[option.longName]);
+};
+exports.create = create;

package/commands/handler/options/utils.d.ts

@@ -0,0 +1,6 @@
+import { Command } from "commander";
+import { Option } from "../../../types";
+export declare const checkOptions: (options: Array<Option> | Option, command: Command) => void;
+export declare const promptForValue: (option: Option) => Promise<string>;
+export declare const setOption: (option: Option, value: string) => void;
+export declare const getValueFromOptionsFile: (filePath: string, { longName }: Option) => Promise<string>;

package/commands/handler/options/utils.js

@@ -0,0 +1,63 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getValueFromOptionsFile = exports.setOption = exports.promptForValue = exports.checkOptions = void 0;
+const prompts_1 = __importDefault(require("prompts"));
+const fs_extra_1 = require("fs-extra");
+const logger_1 = require("../../../logger");
+const commands_1 = require("../../../utils/commands");
+const config_1 = require("../../../config");
+const checkOptions = (options, command) => {
+    const intOptions = Array.isArray(options) ? options : [options];
+    for (const option of intOptions) {
+        if (!(0, commands_1.isOptionAlreadyRegistered)(option, command)) {
+            command.addOption((0, commands_1.buildOption)({ ...option, required: false }));
+        }
+    }
+};
+exports.checkOptions = checkOptions;
+const promptForValue = async (option) => {
+    const { value } = await prompts_1.default.prompt({
+        type: option.prompts.type,
+        choices: option.choices?.map((choice) => ({
+            title: choice,
+            value: choice,
+        })),
+        initial: option.prompts.initial,
+        message: typeof option.prompts.message === "string"
+            ? option.prompts.message
+            : option.prompts.message(),
+        name: "value",
+    });
+    if (option.prompts?.inputValidator) {
+        if (!option.prompts.inputValidator(value)) {
+            throw new Error(`input validator returned false for value ${value}`);
+        }
+    }
+    return value;
+};
+exports.promptForValue = promptForValue;
+const buildOptionName = (option) => `--${option.longName}`;
+const setOption = (option, value) => {
+    const { output } = (0, logger_1.get)("handler.options");
+    if (!value && (option.args || []).length > 0) {
+        const name = buildOptionName(option);
+        output(`error: required option '${name}' not specified`);
+        throw new Error(`no value provided for option ${option.longName}`);
+    }
+    (0, config_1.set)({
+        options: { [option.longName]: value },
+    });
+};
+exports.setOption = setOption;
+const getValueFromOptionsFile = async (filePath, { longName }) => {
+    const options = JSON.parse(await (0, fs_extra_1.readFile)(filePath, { encoding: "utf8" }));
+    if (options[longName]) {
+        return options[longName];
+    }
+    throw new Error(`no value for option ${longName} found in file ${filePath}`);
+};
+exports.getValueFromOptionsFile = getValueFromOptionsFile;

package/commands/handler/or.d.ts

@@ -0,0 +1,2 @@
+import { Handler } from "../../types";
+export declare const create: (...handlers: Array<Handler>) => Handler;

package/commands/handler/or.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const logger_1 = require("../../logger");
+const getLogger = () => (0, logger_1.get)("commands.handlers.or");
+const create = (...handlers) => {
+    const { stack } = new Error();
+    return (command) => {
+        const commandHandlers = [];
+        for (const handler of handlers) {
+            commandHandlers.push(handler(command));
+        }
+        return async (...args) => {
+            const { debug, trace } = getLogger();
+            let handlerFailed = false;
+            for (const handler of commandHandlers) {
+                handlerFailed = false;
+                try {
+                    // eslint-disable-next-line
+                    await handler(...args);
+                    trace(`handler succeeded, exiting loop`);
+                    break;
+                }
+                catch (err) {
+                    debug(`handler failed`, err.stack || err);
+                    handlerFailed = true;
+                }
+            }
+            if (handlerFailed) {
+                trace("handler was created from:", stack);
+                throw new Error("all handlers failed");
+            }
+        };
+    };
+};
+exports.create = create;
+/* jscpd:ignore-end */

package/commands/handler/parseArguments.d.ts

@@ -0,0 +1,4 @@
+import { Handler } from "../../types";
+export declare const create: (handlerArgs?: Array<{
+    argument: string;
+}>) => Handler;

package/commands/handler/parseArguments.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const lodash_1 = require("lodash");
+const config_1 = require("../../config");
+const utils_1 = require("./utils");
+const constants_1 = require("../../constants");
+const logger_1 = require("../../logger");
+const create = (handlerArgs) => () => async (...args) => {
+    const { debug } = (0, logger_1.get)("commands.handler.parseArguments");
+    const command = args[args.length - 1].name();
+    const options = Object.entries(args[args.length - 2])
+        .map((o) => [o[0], (0, utils_1.parseOption)(o[1])])
+        .reduce((prev, curr) => ({ ...prev, [(0, lodash_1.kebabCase)(curr[0])]: curr[1] }), {});
+    const commandArgs = handlerArgs
+        ? handlerArgs.reduce((p, c, i) => ({ ...p, [c.argument]: args[i] }), {})
+        : {};
+    const verbose = (0, utils_1.getBooleanOption)(options[constants_1.OPTION_VERBOSE.longName]);
+    debug("setting command: %s, options: %s, arguments: %s, verbose: %s", command, JSON.stringify(options), JSON.stringify(commandArgs), verbose);
+    (0, config_1.set)({ command, options, arguments: commandArgs, verbose });
+};
+exports.create = create;

package/commands/handler/resilient.d.ts

@@ -0,0 +1,2 @@
+import { Handler } from "../../types";
+export declare const create: (handler: Handler) => Handler;

package/commands/handler/resilient.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const logger_1 = require("../../logger");
+const create = (handler) => (command) => {
+    const commandHandler = handler(command);
+    return async (...args) => {
+        try {
+            await commandHandler(...args);
+        }
+        catch (err) {
+            const { error } = (0, logger_1.get)("commands.handler.resilient");
+            error("handler failed, ignoring it silently", err);
+        }
+    };
+};
+exports.create = create;
+/* jscpd:ignore-end */

package/commands/handler/root/index.d.ts

@@ -0,0 +1,2 @@
+import { Handler } from "../../../types";
+export declare const create: (handler: Handler, errorMessage?: string) => Handler;

package/commands/handler/root/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const logger_1 = require("../../../logger");
+const create = (handler, errorMessage = "Command failed") => (command) => {
+    const { output } = (0, logger_1.get)("handler.root");
+    const hdlr = handler(command);
+    return async (...args) => {
+        try {
+            await hdlr(...args);
+        }
+        catch (err) {
+            output(errorMessage);
+            throw err;
+        }
+    };
+};
+exports.create = create;

package/commands/handler/stackTrace.d.ts

@@ -0,0 +1,2 @@
+import { Handler } from "../../types";
+export declare const create: (handler: Handler) => Handler;

package/commands/handler/stackTrace.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const logger_1 = require("../../logger");
+const create = (handler) => {
+    const { stack } = new Error();
+    return (command) => {
+        const commandHandler = handler(command);
+        return async (...args) => {
+            try {
+                await commandHandler(...args);
+            }
+            catch (err) {
+                const { trace } = (0, logger_1.get)("commands.handler.stackTrace");
+                trace("handler was created from:", stack);
+                throw err;
+            }
+        };
+    };
+};
+exports.create = create;
+/* jscpd:ignore-end */

package/commands/handler/succeed.d.ts

@@ -0,0 +1,2 @@
+import { Handler } from "../../types";
+export declare const create: () => Handler;