@flowscripter/dynamic-cli-framework 12.0.1 → 12.2.0

package/dist/src/service/configuration/command/ConfigDumpSubCommand.js

@@ -2,25 +2,20 @@ import { PRINTER_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
 import { SYNTAX_HIGHLIGHTER_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
 /**
  * Member of the `config` group which dumps the configuration loaded by
- * {@link ConfigurationServiceProvider}.
- *
- * Takes a direct reference to {@link ConfigurationServiceProvider.getConfigString}, wired by the
- * provider that constructs this command, rather than looking it up via {@link Context} -
- * deliberately, since a full config dump is not something every command/task should be able to
- * reach through a general lookup (see {@link ConfigurationService}'s doc comment).
+ * {@link DefaultConfigurationService}, with secrets masked.
  */
 export default class ConfigDumpSubCommand {
     name = "dump";
     description = "Dump configuration values";
     options = [];
     positionals = [];
-    #getConfigString;
-    constructor(getConfigString) {
-        this.#getConfigString = getConfigString;
+    #configurationService;
+    constructor(configurationService) {
+        this.#configurationService = configurationService;
     }
     async execute(context) {
         const printerService = context.getServiceById(PRINTER_SERVICE_ID);
         const syntaxHighlighterService = context.getServiceById(SYNTAX_HIGHLIGHTER_SERVICE_ID);
-        await printerService.print(`${syntaxHighlighterService.highlight(this.#getConfigString(), "json")}\n`);
+        await printerService.print(`${syntaxHighlighterService.highlight(this.#configurationService.getMaskedConfigString(), "json")}\n`);
     }
 }

package/dist/src/service/configuration/command/ConfigGetSubCommand.d.ts

@@ -0,0 +1,16 @@
+import { type Context, type Option, type Positional, type SubCommand, type Values } from "@flowscripter/dynamic-cli-framework-api";
+import type DefaultConfigurationService from "../DefaultConfigurationService.ts";
+/**
+ * Member of the `config` group which shows the configurable commands, their options and the
+ * values currently stored for them. SECRET values are masked.
+ */
+export default class ConfigGetSubCommand implements SubCommand {
+    #private;
+    readonly name = "get";
+    readonly description = "Show configurable commands, their options and stored default values";
+    readonly options: ReadonlyArray<Option>;
+    readonly positionals: ReadonlyArray<Positional>;
+    constructor(configurationService: DefaultConfigurationService);
+    execute(context: Context, argumentValues: Values): Promise<void>;
+}
+//# sourceMappingURL=ConfigGetSubCommand.d.ts.map

package/dist/src/service/configuration/command/ConfigGetSubCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfigGetSubCommand.d.ts","sourceRoot":"","sources":["../../../../../src/service/configuration/command/ConfigGetSubCommand.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,OAAO,EACZ,KAAK,MAAM,EAEX,KAAK,UAAU,EAEf,KAAK,UAAU,EACf,KAAK,MAAM,EACZ,MAAM,yCAAyC,CAAC;AACjD,OAAO,KAAK,2BAA2B,MAAM,mCAAmC,CAAC;AA6CjF;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,mBAAoB,YAAW,UAAU;;IAC5D,QAAQ,CAAC,IAAI,SAAS;IACtB,QAAQ,CAAC,WAAW,yEAAyE;IAC7F,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,CAarC;IACF,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC,UAAU,CAAC,CAAM;IAIrD,YAAmB,oBAAoB,EAAE,2BAA2B,EAEnE;IAEY,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAwC5E;CAwEF"}

package/dist/src/service/configuration/command/ConfigGetSubCommand.js

@@ -0,0 +1,137 @@
+import { PRINTER_SERVICE_ID, ValueTypeName, } from "@flowscripter/dynamic-cli-framework-api";
+import { isComplexOption } from "../../../runtime/argument/ArgumentTypeGuards.js";
+import { isOverriddenByEnvVar, maskDefault, } from "../configTargets.js";
+function typeName(option) {
+    const name = isComplexOptionLike(option) ? "COMPLEX" : ValueTypeName[option.type];
+    return option.isArray === true ? `${name}[]` : name;
+}
+function isComplexOptionLike(option) {
+    return option.type === 5;
+}
+function constraints(option) {
+    const parts = [];
+    if (option.allowableValues !== undefined) {
+        parts.push(`one of: ${option.allowableValues.join(", ")}`);
+    }
+    if (option.minValueInclusive !== undefined || option.maxValueInclusive !== undefined) {
+        parts.push(`range: ${option.minValueInclusive ?? ""}..${option.maxValueInclusive ?? ""}`);
+    }
+    return parts.length === 0 ? "" : ` (${parts.join("; ")})`;
+}
+function mismatch(option, value) {
+    if (value === undefined || isComplexOption(option) || option.isArray === true) {
+        return false;
+    }
+    switch (option.type) {
+        case ValueTypeName.BOOLEAN:
+            return typeof value !== "boolean";
+        case ValueTypeName.INTEGER:
+            return !Number.isInteger(value);
+        case ValueTypeName.NUMBER:
+            return typeof value !== "number";
+        default:
+            return typeof value !== "string";
+    }
+}
+/**
+ * Member of the `config` group which shows the configurable commands, their options and the
+ * values currently stored for them. SECRET values are masked.
+ */
+export default class ConfigGetSubCommand {
+    name = "get";
+    description = "Show configurable commands, their options and stored default values";
+    options = [
+        {
+            name: "command",
+            type: ValueTypeName.STRING,
+            description: "Show only this command (or <group>:<member>)",
+            isOptional: true,
+            validate: (value) => {
+                const targets = this.#configurationService.getConfigTargets();
+                return targets.has(value)
+                    ? undefined
+                    : `unknown or non-configurable command, valid commands: ${[...targets.keys()].join(", ")}`;
+            },
+        },
+    ];
+    positionals = [];
+    #configurationService;
+    constructor(configurationService) {
+        this.#configurationService = configurationService;
+    }
+    async execute(context, argumentValues) {
+        const printer = context.getServiceById(PRINTER_SERVICE_ID);
+        const targets = this.#configurationService.getConfigTargets();
+        const selected = argumentValues["command"];
+        const keys = selected === undefined ? [...targets.keys()] : [selected];
+        if (selected === undefined) {
+            for (const key of this.#configurationService.defaultsData.keys()) {
+                if (!targets.has(key)) {
+                    keys.push(key);
+                }
+            }
+        }
+        const lines = [];
+        for (const key of keys) {
+            const target = targets.get(key);
+            const stored = this.#configurationService.defaultsData.get(key);
+            if (target === undefined) {
+                lines.push(`${key}  (unknown command, not configurable)`);
+                lines.push(`  ${JSON.stringify(maskDefault(undefined, stored))}`);
+                continue;
+            }
+            lines.push(key);
+            if (target.argument !== undefined) {
+                lines.push(`  ${typeName(target.argument)}${constraints(target.argument)} = ${this.#show(context, target, [], stored)}`);
+                continue;
+            }
+            const values = (stored ?? {});
+            this.#listOptions(context, target, target.options, [], "", values, lines);
+            for (const name of Object.keys(values)) {
+                if (!target.options.some((o) => o.name === name)) {
+                    lines.push(`  ${name}  (unknown option) = ${JSON.stringify(maskDefault(undefined, values[name]))}`);
+                }
+            }
+        }
+        await printer.print(`${lines.join("\n")}\n`);
+    }
+    #show(context, target, steps, value) {
+        if (value === undefined) {
+            return isOverriddenByEnvVar(this.#configurationService, context.cliConfig, target, steps)
+                ? "(not set; overridden by an environment variable)"
+                : "(not set)";
+        }
+        const text = JSON.stringify(maskDefault(target, value));
+        return isOverriddenByEnvVar(this.#configurationService, context.cliConfig, target, steps)
+            ? `${text} (overridden by an environment variable)`
+            : text;
+    }
+    #listOptions(context, target, options, steps, prefix, values, lines) {
+        for (const option of options) {
+            const path = `${prefix}${option.name}`;
+            const optionSteps = [...steps, { name: option.name }];
+            const value = values?.[option.name];
+            const flag = mismatch(option, value) ? " (type mismatch)" : "";
+            const indent = "  ".repeat(optionSteps.length);
+            const optional = option.isOptional === true || option.defaultValue !== undefined ? "" : " required";
+            const detail = isComplexOption(option) ? "" : constraints(option);
+            const shown = value === undefined
+                ? this.#show(context, target, optionSteps, undefined)
+                : this.#showValue(context, target, optionSteps, option, value);
+            lines.push(`${indent}${path}  ${typeName(option)}${optional}${detail} = ${shown}${flag}`);
+            if (isComplexOption(option) && option.isArray !== true) {
+                this.#listOptions(context, target, option.properties, optionSteps, `${path}.`, typeof value === "object" && value !== null
+                    ? value
+                    : undefined, lines);
+            }
+        }
+    }
+    #showValue(context, target, steps, option, value) {
+        const wrapper = { ...target, argument: undefined, options: [option] };
+        const masked = maskDefault(wrapper, { [option.name]: value });
+        const text = JSON.stringify(masked[option.name]);
+        return isOverriddenByEnvVar(this.#configurationService, context.cliConfig, target, steps)
+            ? `${text} (overridden by an environment variable)`
+            : text;
+    }
+}

package/dist/src/service/configuration/command/ConfigSetSubCommand.d.ts

@@ -0,0 +1,18 @@
+import { type Context, type Option, type Positional, type SubCommand, type Values } from "@flowscripter/dynamic-cli-framework-api";
+import type DefaultConfigurationService from "../DefaultConfigurationService.ts";
+/**
+ * Member of the `config` group which sets a default value for an option of a configurable command.
+ *
+ * Values are validated against the option declared by the target command (type, allowable values,
+ * range and custom validators) but the target's required checks are not applied.
+ */
+export default class ConfigSetSubCommand implements SubCommand {
+    #private;
+    readonly name = "set";
+    readonly description = "Set a default value for an option of a command";
+    readonly options: ReadonlyArray<Option>;
+    readonly positionals: ReadonlyArray<Positional>;
+    constructor(configurationService: DefaultConfigurationService, readStdinFn?: () => Promise<string>);
+    execute(context: Context, argumentValues: Values): Promise<void>;
+}
+//# sourceMappingURL=ConfigSetSubCommand.d.ts.map

package/dist/src/service/configuration/command/ConfigSetSubCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfigSetSubCommand.d.ts","sourceRoot":"","sources":["../../../../../src/service/configuration/command/ConfigSetSubCommand.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,OAAO,EACZ,KAAK,MAAM,EACX,KAAK,UAAU,EAGf,KAAK,UAAU,EACf,KAAK,MAAM,EACZ,MAAM,yCAAyC,CAAC;AACjD,OAAO,KAAK,2BAA2B,MAAM,mCAAmC,CAAC;AAqBjF;;;;;GAKG;AACH,MAAM,CAAC,OAAO,OAAO,mBAAoB,YAAW,UAAU;;IAC5D,QAAQ,CAAC,IAAI,SAAS;IACtB,QAAQ,CAAC,WAAW,oDAAoD;IACxE,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,CAwDrC;IACF,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC,UAAU,CAAC,CAAM;IAKrD,YACE,oBAAoB,EAAE,2BAA2B,EACjD,WAAW,GAAE,MAAM,OAAO,CAAC,MAAM,CAAa,EAI/C;IAqEK,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA2LrE;CA+BF"}

package/dist/src/service/configuration/command/ConfigSetSubCommand.js

@@ -0,0 +1,289 @@
+import { ARGUMENT_PROMPTER_SERVICE_ID, PRINTER_SERVICE_ID, ValueTypeName, Icon, } from "@flowscripter/dynamic-cli-framework-api";
+import { isComplexOption } from "../../../runtime/argument/ArgumentTypeGuards.js";
+import { applyChanges, containsSecret, isOverriddenByEnvVar, prepareChange, prepareGlobalValue, resolveOptionPath, setAtPath, } from "../configTargets.js";
+async function readStdin() {
+    return await Bun.stdin.text();
+}
+/**
+ * Member of the `config` group which sets a default value for an option of a configurable command.
+ *
+ * Values are validated against the option declared by the target command (type, allowable values,
+ * range and custom validators) but the target's required checks are not applied.
+ */
+export default class ConfigSetSubCommand {
+    name = "set";
+    description = "Set a default value for an option of a command";
+    options = [
+        {
+            name: "command",
+            type: ValueTypeName.STRING,
+            description: "The command (or <group>:<member>) to set a default for",
+            isOptional: true,
+            validate: (value) => this.#validateCommand(value),
+        },
+        {
+            name: "option",
+            type: ValueTypeName.STRING,
+            description: "The option to set, for nested or array options a path such as 'address[1].port'. Omit for a global command.",
+            isOptional: true,
+            validate: (value, ctx) => {
+                const target = this.#targetOf(ctx.values);
+                if (target === undefined) {
+                    return undefined;
+                }
+                if (target.argument !== undefined) {
+                    return `command '${target.key}' has no options: omit --option`;
+                }
+                const resolved = resolveOptionPath(target, value);
+                return typeof resolved === "string" ? this.#withValidOptions(target, resolved) : undefined;
+            },
+        },
+        {
+            name: "value",
+            type: ValueTypeName.STRING,
+            description: "The value to set. Arrays and complex options take a JSON value. Prefer a prompt or --value-stdin for SECRET options.",
+            isOptional: true,
+            validate: (value, ctx) => {
+                const target = this.#targetOf(ctx.values);
+                if (target === undefined) {
+                    return undefined;
+                }
+                const values = ctx.values;
+                const result = this.#prepare(target, values["option"], value);
+                return typeof result === "string" ? result : undefined;
+            },
+        },
+        {
+            name: "value-stdin",
+            type: ValueTypeName.BOOLEAN,
+            description: "Read the value from stdin instead of --value",
+            isOptional: true,
+            validate: (value, ctx) => value === true && ctx.values["value"] !== undefined
+                ? "cannot be combined with --value"
+                : undefined,
+        },
+    ];
+    positionals = [];
+    #configurationService;
+    #readStdin;
+    constructor(configurationService, readStdinFn = readStdin) {
+        this.#configurationService = configurationService;
+        this.#readStdin = readStdinFn;
+    }
+    #validateCommand(command) {
+        const targets = this.#configurationService.getConfigTargets();
+        return targets.has(command)
+            ? undefined
+            : `unknown or non-configurable command, valid commands: ${[...targets.keys()].join(", ")}`;
+    }
+    #targetOf(values) {
+        const command = values["command"];
+        return typeof command === "string"
+            ? this.#configurationService.getConfigTargets().get(command)
+            : undefined;
+    }
+    #withValidOptions(target, message) {
+        return `${message}, valid options: ${target.options.map((o) => o.name).join(", ")}`;
+    }
+    /**
+     * Validate and convert a raw value and apply it to a copy of the stored defaults (running the
+     * target's custom validators).
+     */
+    #prepare(target, option, raw) {
+        const deferred = [];
+        if (target.argument !== undefined) {
+            if (option !== undefined) {
+                return `command '${target.key}' has no options: omit --option`;
+            }
+            return prepareGlobalValue(target, raw, deferred);
+        }
+        if (option === undefined) {
+            return "--option is required with --value";
+        }
+        const change = prepareChange(target, option, raw, deferred);
+        if (typeof change === "string") {
+            return change;
+        }
+        const applied = applyChanges(target, this.#configurationService.defaultsData.get(target.key), [change], deferred);
+        return typeof applied === "string" ? applied : { change, isSecret: change.isSecret };
+    }
+    async #promptFor(context, args, missing) {
+        if (context.doesServiceExist(ARGUMENT_PROMPTER_SERVICE_ID)) {
+            const prompter = context.getServiceById(ARGUMENT_PROMPTER_SERVICE_ID);
+            const values = await prompter.promptForArguments(args);
+            if (values !== undefined) {
+                return values;
+            }
+        }
+        throw new Error(`${missing} (prompting is not available)`);
+    }
+    async execute(context, argumentValues) {
+        const printer = context.getServiceById(PRINTER_SERVICE_ID);
+        const targets = this.#configurationService.getConfigTargets();
+        const commandNames = [...targets.keys()];
+        let commandKey = argumentValues["command"];
+        if (commandKey === undefined) {
+            const prompted = await this.#promptFor(context, [
+                {
+                    name: "command",
+                    description: "Command to configure",
+                    type: ValueTypeName.STRING,
+                    allowableValues: commandNames,
+                },
+            ], `--command is required, valid commands: ${commandNames.join(", ")}`);
+            commandKey = prompted["command"];
+        }
+        const target = targets.get(commandKey);
+        if (target === undefined) {
+            throw new Error(`Unknown or non-configurable command '${commandKey}'`);
+        }
+        const optionPath = argumentValues["option"];
+        let raw = argumentValues["value"];
+        if (argumentValues["value-stdin"] === true) {
+            if (context.isTty.stdin) {
+                throw new Error("--value-stdin requires the value to be piped to stdin, or use the prompt");
+            }
+            raw = (await this.#readStdin()).replace(/\r?\n$/, "");
+            if (raw === "") {
+                throw new Error("No value was provided on stdin");
+            }
+            if (target.argument === undefined && optionPath === undefined) {
+                throw new Error("--option is required with --value-stdin");
+            }
+        }
+        const deferred = [];
+        const changes = [];
+        let globalValue;
+        let globalIsSecret = false;
+        if (target.argument !== undefined) {
+            if (optionPath !== undefined) {
+                throw new Error(`Command '${target.key}' has no options: omit --option`);
+            }
+            if (raw === undefined) {
+                const prompted = await this.#promptFor(context, [
+                    {
+                        description: `Value for ${target.key}`,
+                        ...target.argument,
+                        name: "value",
+                        isOptional: false,
+                    },
+                ], "--value is required");
+                globalValue = prompted["value"];
+                globalIsSecret = target.argument.type === ValueTypeName.SECRET;
+            }
+            else {
+                const result = prepareGlobalValue(target, raw, deferred);
+                if (typeof result === "string") {
+                    throw new Error(result);
+                }
+                globalValue = result.value;
+                globalIsSecret = result.isSecret;
+                await this.#warnIfSecretArgument(context, printer, globalIsSecret, argumentValues);
+            }
+        }
+        else if (optionPath === undefined && raw !== undefined) {
+            throw new Error("--option is required with --value");
+        }
+        else if (optionPath === undefined) {
+            const mandatory = target.options.filter((o) => o.isOptional !== true && o.defaultValue === undefined);
+            if (mandatory.length > 0) {
+                const prompted = await this.#promptFor(context, mandatory, `--value is required, mandatory options: ${mandatory.map((o) => o.name).join(", ")}`);
+                for (const option of mandatory) {
+                    changes.push(this.#promptedChange(option, prompted[option.name]));
+                }
+            }
+            else {
+                const names = target.options.map((o) => o.name);
+                const selected = await this.#promptFor(context, [
+                    {
+                        name: "option",
+                        description: "Option to set",
+                        type: ValueTypeName.STRING,
+                        allowableValues: names,
+                    },
+                ], `--option is required, valid options: ${names.join(", ")}`);
+                const option = target.options.find((o) => o.name === selected["option"]);
+                const prompted = await this.#promptFor(context, [{ ...option, isOptional: false }], "--value is required");
+                changes.push(this.#promptedChange(option, prompted[option.name]));
+            }
+        }
+        else {
+            const resolved = resolveOptionPath(target, optionPath);
+            if (typeof resolved === "string") {
+                throw new Error(this.#withValidOptions(target, resolved));
+            }
+            if (raw === undefined) {
+                const { leaf, steps } = resolved;
+                const hasIndex = steps[steps.length - 1].index !== undefined;
+                const prompted = await this.#promptFor(context, [{ ...leaf, isArray: hasIndex ? false : leaf.isArray, isOptional: false }], "--value is required");
+                changes.push({
+                    ...this.#promptedChange(leaf, prompted[leaf.name]),
+                    steps,
+                    path: optionPath,
+                });
+            }
+            else {
+                const change = prepareChange(target, optionPath, raw, deferred);
+                if (typeof change === "string") {
+                    throw new Error(change);
+                }
+                changes.push(change);
+                await this.#warnIfSecretArgument(context, printer, change.isSecret, argumentValues);
+            }
+        }
+        const existing = this.#configurationService.defaultsData.get(target.key);
+        if (target.argument === undefined) {
+            const applied = applyChanges(target, existing, changes, deferred);
+            if (typeof applied === "string") {
+                throw new Error(applied);
+            }
+        }
+        const secretChanges = changes.filter((c) => c.isSecret);
+        const secrets = target.argument !== undefined
+            ? globalIsSecret
+                ? [{ key: [target.key], value: globalValue }]
+                : []
+            : secretChanges.map((c) => ({ key: [target.key, c.path], value: c.value }));
+        await this.#configurationService.commitDefault(target.key, secrets, (sentinels) => {
+            if (target.argument !== undefined) {
+                return globalIsSecret ? sentinels[0] : globalValue;
+            }
+            const values = structuredClone(existing ?? {});
+            for (const change of changes) {
+                const secretIndex = secretChanges.indexOf(change);
+                setAtPath(values, change.steps, secretIndex >= 0 ? sentinels[secretIndex] : change.value);
+            }
+            return values;
+        });
+        for (const change of target.argument !== undefined ? [] : changes) {
+            await printer.info(`Set default ${target.key}.${change.path}\n`);
+            if (isOverriddenByEnvVar(this.#configurationService, context.cliConfig, target, change.steps)) {
+                await printer.warn(`An environment variable overrides the default for ${target.key}.${change.path}\n`, Icon.ALERT);
+            }
+        }
+        if (target.argument !== undefined) {
+            await printer.info(`Set default ${target.key}\n`);
+            if (isOverriddenByEnvVar(this.#configurationService, context.cliConfig, target, [])) {
+                await printer.warn(`An environment variable overrides the default for ${target.key}\n`, Icon.ALERT);
+            }
+        }
+    }
+    #promptedChange(option, value) {
+        if (containsSecret(option) && (isComplexOption(option) || option.isArray === true)) {
+            throw new Error(`Option '${option.name}' contains SECRET values: set each secret property individually using --option`);
+        }
+        return {
+            steps: [{ name: option.name }],
+            path: option.name,
+            leaf: option,
+            value,
+            isSecret: !isComplexOption(option) && option.type === ValueTypeName.SECRET,
+        };
+    }
+    async #warnIfSecretArgument(context, printer, isSecret, argumentValues) {
+        if (isSecret && argumentValues["value-stdin"] !== true && context.isTty.stdin) {
+            await printer.warn("SECRET value passed as a plain argument. This is not recommended as it may be exposed via shell history " +
+                "and process listings (and in debug logs). Use the prompt or --value-stdin instead.\n\n", Icon.ALERT);
+        }
+    }
+}

package/dist/src/service/configuration/command/ConfigUnsetSubCommand.d.ts

@@ -0,0 +1,15 @@
+import { type Context, type Option, type Positional, type SubCommand, type Values } from "@flowscripter/dynamic-cli-framework-api";
+import type DefaultConfigurationService from "../DefaultConfigurationService.ts";
+/**
+ * Member of the `config` group which removes a stored default value (and any OS secret it refers to).
+ */
+export default class ConfigUnsetSubCommand implements SubCommand {
+    #private;
+    readonly name = "unset";
+    readonly description = "Remove a default value for an option of a command";
+    readonly options: ReadonlyArray<Option>;
+    readonly positionals: ReadonlyArray<Positional>;
+    constructor(configurationService: DefaultConfigurationService);
+    execute(context: Context, argumentValues: Values): Promise<void>;
+}
+//# sourceMappingURL=ConfigUnsetSubCommand.d.ts.map

package/dist/src/service/configuration/command/ConfigUnsetSubCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfigUnsetSubCommand.d.ts","sourceRoot":"","sources":["../../../../../src/service/configuration/command/ConfigUnsetSubCommand.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,OAAO,EACZ,KAAK,MAAM,EACX,KAAK,UAAU,EAEf,KAAK,UAAU,EACf,KAAK,MAAM,EACZ,MAAM,yCAAyC,CAAC;AACjD,OAAO,KAAK,2BAA2B,MAAM,mCAAmC,CAAC;AAKjF;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,qBAAsB,YAAW,UAAU;;IAC9D,QAAQ,CAAC,IAAI,WAAW;IACxB,QAAQ,CAAC,WAAW,uDAAuD;IAC3E,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,CAuCrC;IACF,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC,UAAU,CAAC,CAAM;IAIrD,YAAmB,oBAAoB,EAAE,2BAA2B,EAEnE;IAEK,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAqDrE;CACF"}

package/dist/src/service/configuration/command/ConfigUnsetSubCommand.js

@@ -0,0 +1,101 @@
+import { ARGUMENT_PROMPTER_SERVICE_ID, PRINTER_SERVICE_ID, ValueTypeName, } from "@flowscripter/dynamic-cli-framework-api";
+import { removeAtPath, resolveOptionPath } from "../configTargets.js";
+/**
+ * Member of the `config` group which removes a stored default value (and any OS secret it refers to).
+ */
+export default class ConfigUnsetSubCommand {
+    name = "unset";
+    description = "Remove a default value for an option of a command";
+    options = [
+        {
+            name: "command",
+            type: ValueTypeName.STRING,
+            description: "The command (or <group>:<member>) to remove defaults from",
+            isOptional: true,
+            validate: (value) => {
+                const targets = this.#configurationService.getConfigTargets();
+                return targets.has(value) ||
+                    this.#configurationService.defaultsData.has(value)
+                    ? undefined
+                    : `unknown command, valid commands: ${[...targets.keys()].join(", ")}`;
+            },
+        },
+        {
+            name: "option",
+            type: ValueTypeName.STRING,
+            description: "The option (or option path) to remove. Omit to remove all defaults of the command.",
+            isOptional: true,
+            validate: (value, ctx) => {
+                const target = this.#configurationService
+                    .getConfigTargets()
+                    .get(ctx.values["command"]);
+                if (target === undefined) {
+                    return undefined;
+                }
+                if (target.argument !== undefined) {
+                    return `command '${target.key}' has no options: omit --option`;
+                }
+                const resolved = resolveOptionPath(target, value);
+                if (typeof resolved === "string") {
+                    return `${resolved}, valid options: ${target.options.map((o) => o.name).join(", ")}`;
+                }
+                return resolved.steps[resolved.steps.length - 1].index !== undefined
+                    ? "unsetting an array element is not supported: unset the whole option instead"
+                    : undefined;
+            },
+        },
+    ];
+    positionals = [];
+    #configurationService;
+    constructor(configurationService) {
+        this.#configurationService = configurationService;
+    }
+    async execute(context, argumentValues) {
+        const printer = context.getServiceById(PRINTER_SERVICE_ID);
+        const targets = this.#configurationService.getConfigTargets();
+        let commandKey = argumentValues["command"];
+        if (commandKey === undefined) {
+            const names = [...this.#configurationService.defaultsData.keys()];
+            const prompter = context.doesServiceExist(ARGUMENT_PROMPTER_SERVICE_ID)
+                ? context.getServiceById(ARGUMENT_PROMPTER_SERVICE_ID)
+                : undefined;
+            const prompted = names.length > 0
+                ? await prompter?.promptForArguments([
+                    {
+                        name: "command",
+                        description: "Command to remove defaults from",
+                        type: ValueTypeName.STRING,
+                        allowableValues: names,
+                    },
+                ])
+                : undefined;
+            if (prompted === undefined) {
+                throw new Error(`--command is required, commands with defaults: ${names.join(", ")}`);
+            }
+            commandKey = prompted["command"];
+        }
+        const existing = this.#configurationService.defaultsData.get(commandKey);
+        const optionPath = argumentValues["option"];
+        const target = targets.get(commandKey);
+        if (optionPath !== undefined && target === undefined) {
+            throw new Error(`Unknown or non-configurable command '${commandKey}'`);
+        }
+        let next;
+        let removed = existing !== undefined;
+        if (optionPath !== undefined && existing !== undefined) {
+            const resolved = resolveOptionPath(target, optionPath);
+            if (typeof resolved === "string") {
+                throw new Error(resolved);
+            }
+            const values = structuredClone(existing);
+            removed = removeAtPath(values, resolved.steps);
+            next = Object.keys(values).length > 0 ? values : undefined;
+        }
+        if (!removed) {
+            await printer.info(`Nothing to unset for ${commandKey}${optionPath ? `.${optionPath}` : ""}\n`);
+            return;
+        }
+        await this.#configurationService.commitDefault(commandKey, [], () => next);
+        await printer.info(`Removed default ${commandKey}${optionPath ? `.${optionPath}` : ""}\n`);
+    }
+}