@flowscripter/dynamic-cli-framework 1.7.3 → 1.7.5

package/dist/src/service/completion/shell/fish.js

@@ -0,0 +1,35 @@
+import process from "node:process";
+import { homedir } from "node:os";
+import { join } from "node:path";
+// Reference: https://fishshell.com/docs/current/completions.html
+export default class FishShellHandler {
+    getDefaultConfigPath() {
+        return join(homedir(), ".config", "fish", "config.fish");
+    }
+    getBootstrapScript(cliName, executablePath) {
+        return `complete -c ${cliName} -f -a '("${executablePath}" completion:complete fish (commandline -cp) (commandline -C) 2>/dev/null)'`;
+    }
+    validateEnvironment() {
+        const shell = process.env.SHELL || "";
+        if (shell.endsWith("/fish")) {
+            return Promise.resolve(true);
+        }
+        try {
+            const result = Bun.spawnSync(["fish", "--version"]);
+            return Promise.resolve(result.exitCode === 0);
+        }
+        catch {
+            return Promise.resolve(false);
+        }
+    }
+    formatCompletions(completions) {
+        return completions
+            .map((c) => (c.description ? `${c.value}\t${c.description}` : c.value))
+            .join("\n");
+    }
+    parseCompletionContext(args) {
+        const line = args[0] || "";
+        const cursorPosition = parseInt(args[1] || "0", 10) || line.length;
+        return { line, cursorPosition };
+    }
+}

package/dist/src/service/completion/shell/powershell.js

@@ -0,0 +1,51 @@
+import process from "node:process";
+import { homedir } from "node:os";
+import { join } from "node:path";
+// Reference: https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/register-argumentcompleter
+export default class PowerShellShellHandler {
+    getDefaultConfigPath() {
+        if (process.platform === "win32") {
+            return join(homedir(), "Documents", "PowerShell", "Microsoft.PowerShell_profile.ps1");
+        }
+        return join(homedir(), ".config", "powershell", "Microsoft.PowerShell_profile.ps1");
+    }
+    getBootstrapScript(cliName, executablePath) {
+        return [
+            `Register-ArgumentCompleter -Native -CommandName ${cliName} -ScriptBlock {`,
+            `  param($wordToComplete, $commandAst, $cursorPosition)`,
+            `  $completions = & "${executablePath}" completion:complete powershell "$commandAst" "$cursorPosition" 2>$null`,
+            `  $completions -split '\\n' | ForEach-Object {`,
+            `    [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)`,
+            `  }`,
+            `}`,
+        ].join("\n");
+    }
+    validateEnvironment() {
+        try {
+            const result = Bun.spawnSync(["pwsh", "--version"], { timeout: 2000 });
+            if (result.exitCode === 0) {
+                return Promise.resolve(true);
+            }
+        }
+        catch {
+            // try powershell fallback
+        }
+        try {
+            const result = Bun.spawnSync(["powershell", "-Command", "echo ok"], {
+                timeout: 2000,
+            });
+            return Promise.resolve(result.exitCode === 0);
+        }
+        catch {
+            return Promise.resolve(false);
+        }
+    }
+    formatCompletions(completions) {
+        return completions.map((c) => c.value).join("\n");
+    }
+    parseCompletionContext(args) {
+        const line = args[0] || "";
+        const cursorPosition = parseInt(args[1] || "0", 10) || line.length;
+        return { line, cursorPosition };
+    }
+}

package/dist/src/service/completion/shell/zsh.js

@@ -0,0 +1,42 @@
+import process from "node:process";
+import { homedir } from "node:os";
+import { join } from "node:path";
+// Reference: https://zsh.sourceforge.io/Doc/Release/Completion-System.html
+export default class ZshShellHandler {
+    getDefaultConfigPath() {
+        return join(homedir(), ".zshrc");
+    }
+    getBootstrapScript(cliName, executablePath) {
+        return [
+            `_${cliName}_completions() {`,
+            `  local -a completions`,
+            `  completions=("\${(@f)$("${executablePath}" completion:complete zsh "\${words}" "\${CURSOR}" 2>/dev/null)}")`,
+            `  _describe '${cliName}' completions`,
+            `}`,
+            `compdef _${cliName}_completions ${cliName}`,
+        ].join("\n");
+    }
+    validateEnvironment() {
+        const shell = process.env.SHELL || "";
+        if (shell.endsWith("/zsh")) {
+            return Promise.resolve(true);
+        }
+        try {
+            const result = Bun.spawnSync(["zsh", "--version"]);
+            return Promise.resolve(result.exitCode === 0);
+        }
+        catch {
+            return Promise.resolve(false);
+        }
+    }
+    formatCompletions(completions) {
+        return completions
+            .map((c) => (c.description ? `${c.value}:${c.description}` : c.value))
+            .join("\n");
+    }
+    parseCompletionContext(args) {
+        const line = args[0] || "";
+        const cursorPosition = parseInt(args[1] || "0", 10) || line.length;
+        return { line, cursorPosition };
+    }
+}

package/dist/src/service/configuration/ConfigurationServiceProvider.js

@@ -0,0 +1,482 @@
+import process from "node:process";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { Stats } from "node:fs";
+import ConfigCommand from "./command/ConfigCommand.js";
+import getLogger from "../../util/logger.js";
+import DumpConfigCommand from "./command/DumpConfigCommand.js";
+import { KEY_VALUE_SERVICE_ID, SECRET_SENTINEL_PREFIX, } from "../../api/service/core/KeyValueService.js";
+import DefaultKeyValueService from "./DefaultKeyValueService.js";
+import DefaultSecretService from "./DefaultSecretService.js";
+import argumentValueMerge from "../../runtime/values/argumentValueMerge.js";
+import { isGlobalCommand, isGlobalModifierCommand, isSubCommand, } from "../../runtime/command/CommandTypeGuards.js";
+import { getGlobalCommandValueFromEnvVars, getSubCommandValuesFromEnvVars, } from "../../util/envVarHelper.js";
+const logger = getLogger("ConfigurationServiceProvider");
+/**
+ * Provides:
+ *
+ * * Configuration of default command arguments using a configuration file and/or environment variables.
+ * * A generic key-value store for commands and services ({@link KeyValueService}).
+ *
+ * **Default Command Arguments**
+ *
+ * Configuration of default {@link ArgumentValues} for {@link Command} instances is supported if they
+ * have defined {@link Command.enableConfiguration} as `true`.
+ *
+ * Two sources of configuration are supported and both are expected to be manually managed by the user of the CLI.
+ *
+ * *Configuration File*
+ *
+ * A JSON file where the structure matches {@link ArgumentValues} and the defaults are stored
+ * under a top level `defaults` property. The second level of properties is used to refer to {@link Command.name}
+ * and the contained values are treated as command {@link ArgumentValues}. As an example:
+ *
+ * ```
+ * {
+ *     "defaults": {
+ *         "subCommand1": {
+ *             "arg1": [
+ *                 1,
+ *                 2
+ *             ],
+ *             "arg2": {
+ *                 "arg3": "foo"
+ *             }
+ *         },
+ *         "command2": {
+ *             "arg4": true
+ *         },
+ *         "globalCommand": "globalArgumentValue"
+ *     },
+ *     "key-values": {
+ *         ...
+ *     }
+ * }
+ * ```
+ *
+ * The default location of the configuration file is `$HOME/.<application_name>.json`. If `$HOME` is not defined no
+ * default configuration will be used. The location of the configuration file can be modified via the
+ * {@link ConfigCommand}.
+ *
+ * NOTE: You may store default arguments for secrets by manually configuring secrets in your OS
+ * credential store and referencing them in the config file using the sentinel format
+ * `__SECRET__:<bun_secret_name>`. These values will be resolved from the OS secret store
+ * before being returned as default argument values. See "Generic Key-Value Service" below.
+ *
+ * *Environment Variables*
+ *
+ * Values are parsed using a key path defined by custom {@link Argument.configurationKey}
+ * values or using the default naming scheme defined within {@link Argument.configurationKey}.
+ *
+ * NOTE: Any values set by environment variables will override those sourced from the configuration file.
+ *
+ * The argument key path is derived for an argument (or nested argument) as follows:
+ *
+ * Argument configuration keys are concatenated with a `_` separator.
+ * Any arguments which support array values must by suffixed with `_` and an explicit array index.
+ * If the root argument in the path does not use a custom {@link Argument.configurationKey} then the key path
+ * is additionally suffixed with the {@link CLIConfig.name} and the {@link Command.name} with `_` separators.
+ * This is best explained with examples...
+ *
+ * No custom configuration key examples:
+ *
+ * * executable: `MyCLI`, command: `globalCommand1`, global command argument => environment variable: `MYCLI_GLOBALCOMMAND1`
+ * * executable: `MyCLI`, command: `command1`, simple root argument: `arg1` => environment variable: `MYCLI_COMMAND1_ARG1`
+ * * executable: `MyCLI`, command: `command1`, array root argument, 1st element: `arg2[0]` => environment variable: `MYCLI_COMMAND1_ARG2_0`
+ * * executable: `MyCLI`, command: `command1`, argument is a digit so it is by default suffixed with `_`: `3` => environment variable: `MYCLI_COMMAND1__3`
+ * * executable: `MyCLI`, command: `command1`, nested sub-argument: `arg1.arg2` => environment variable: `MYCLI_COMMAND1_ARG1_ARG2`
+ * * executable: `MyCLI`, command: `command1`, nested sub-argument with both levels being arrays and referring to the 2nd element of each: `arg1[1].arg2[1]` => environment variable: `MYCLI_COMMAND1_ARG1_1_ARG2_2`
+ *
+ * Custom configuration key at the root level (and therefore not prefixed with CLI and command names) examples:
+ *
+ * * executable: `MyCLI`, command: `globalCommand1`, global command argument`, global command argument configuration key: `FOO` => environment variable: `FOO`
+ * * executable: `MyCLI`, command: `command1`, simple root argument: `arg1`, arg1 configuration key: `FOO` => environment variable: `FOO`
+ * * executable: `MyCLI`, command: `command1`, array root argument, 1st element: `arg2[0]`, arg1 configuration key: `BAR` => environment variable: `BAR_0`
+ *
+ * Custom configuration key not at the root level (and therefore prefixed with CLI and command names) examples:
+ *
+ * * executable: `MyCLI`, command: `command1`, nested sub-argument: `arg1.arg2`, arg2 configuration key: `FOO` => environment variable: `MYCLI_COMMAND1_ARG1_FOO`
+ * * executable: `MyCLI`, command: `command1`, nested sub-argument with both levels being arrays and referring to the 2nd element of each: `arg1[1].arg2[1]`, arg2 configuration key: `BAR` => environment variable: `MYCLI_COMMAND1_ARG1_1_BAR_2`
+ *
+ * NOTE: Any default values from the above configuration sources will be overridden by any arguments provided on the command line.
+ *
+ * **Generic Key-Value Service**
+ *
+ * The same configuration file above is used to provide storage for the provided {@link KeyValueService}. The values
+ * are stored under a top level `key-values` property. These are expected to not be modified by the user of the CLI.
+ *
+ * The second and third level of properties is used to scope the key-values to specific command names
+ * (via {@link Command.name} values) and specific service IDs (via {@link ServiceProvider.serviceId} values).
+ * Both keys and values are string based.
+ *
+ * Values may be stored as OS-native secrets via {@link KeyValueService.setKey} with `isSecret=true`.
+ * When a value is stored as a secret, a sentinel value of the format `__SECRET__:<bun_secret_name>`
+ * is stored in the config file instead of the actual value. The actual value is stored in the OS
+ * credential store via Bun.secrets. The sentinel prefix `__SECRET__:` is reserved and must not be
+ * used for regular key-value data.
+ *
+ * Secret support requires `secretServiceEnabled=true` in the constructor (which also requires
+ * `configEnabled=true`).
+ *
+ * As an example:
+ * ```
+ * {
+ *    "defaults": {
+ *        ...
+ *    },
+ *    "key-values": {
+ *        "commands": {
+ *            "command1": {
+ *               "foo1": "bar1",
+ *               "foo2": "__SECRET__:command_command1_foo2"
+ *            },
+ *            "command2": {
+ *                "foo1": "bar3"
+ *            }
+ *        },
+ *        "services": {
+ *            "service-id-1": {
+ *                "foo1": "bar"
+ *            }
+ *        }
+ *    }
+ * }
+ * ```
+ */
+export default class ConfigurationServiceProvider {
+    serviceId = KEY_VALUE_SERVICE_ID;
+    servicePriority;
+    envVarsEnabled;
+    configEnabled;
+    keyValueServiceEnabled;
+    secretServiceEnabled;
+    // the location of the currently managed configuration data
+    configLocation;
+    // the configuration data to be used by the CLI runner implementation when setting command defaults.
+    // ArgumentSingleValueType is for GlobalCommandArgument values, ArgumentValues is for
+    // SubCommandArgument values.
+    defaultsData = new Map();
+    // the configuration data to be used by the CLI runner implementation
+    // when updating command scoped access to key-value data via the key-value service.
+    #commandKeyValueData = new Map();
+    // the configuration data to be used by the CLI runner implementation
+    // when updating service scoped access to key-value data via the key-value service.
+    #serviceKeyValueData = new Map();
+    // the optional service providing scope limited key-value data to commands and other services
+    #defaultKeyValueService;
+    // the optional service providing OS-native secret storage
+    #defaultSecretService;
+    #currentCommandNameKeyValueScope;
+    #currentServiceIdKeyValueScope;
+    /**
+     * Create an instance of the service provider with the specified details.
+     *
+     * @param servicePriority the priority of the service.
+     * @param envVarsEnabled optionally support checking env variables for default argument values.
+     * @param configEnabled optionally enable configuration file support for default argument values.
+     * @param keyValueServiceEnabled optionally provide a {@link KeyValueService} implementation: `configEnabled` must be true in this case
+     * @param secretServiceEnabled optionally enable OS-native secret storage via Bun.secrets: `configEnabled` must be true in this case
+     */
+    constructor(servicePriority, envVarsEnabled = false, configEnabled = false, keyValueServiceEnabled = false, secretServiceEnabled = false) {
+        if (!configEnabled && keyValueServiceEnabled) {
+            throw new Error("configEnabled must be true if keyValueServiceEnabled is true");
+        }
+        if (!configEnabled && secretServiceEnabled) {
+            throw new Error("configEnabled must be true if secretServiceEnabled is true");
+        }
+        this.servicePriority = servicePriority;
+        this.envVarsEnabled = envVarsEnabled;
+        this.configEnabled = configEnabled;
+        this.keyValueServiceEnabled = keyValueServiceEnabled;
+        this.secretServiceEnabled = secretServiceEnabled;
+    }
+    getServiceInfo(cliConfig) {
+        const commands = [];
+        if (this.configEnabled) {
+            commands.push(new ConfigCommand(this, this.servicePriority));
+            commands.push(new DumpConfigCommand(this));
+        }
+        if (this.secretServiceEnabled) {
+            this.#defaultSecretService = new DefaultSecretService(cliConfig.name);
+        }
+        if (this.keyValueServiceEnabled || this.secretServiceEnabled) {
+            this.#defaultKeyValueService = new DefaultKeyValueService(this.#defaultSecretService);
+        }
+        return Promise.resolve({
+            // this may be undefined if keyValueServiceEnabled and secretServiceEnabled are false
+            service: this.#defaultKeyValueService,
+            // this may be empty if configEnabled is false
+            commands,
+        });
+    }
+    setConfigLocation(configLocation) {
+        this.configLocation = configLocation;
+    }
+    /**
+     * Retrieve the default command argument values (if any) for the provided {@link Command}.
+     *
+     * This will retrieve values both from the configuration location and environment variables.
+     *
+     * @param cliConfig the {@link CLIConfig} to use for retrieving configuration keys.
+     * @param command the {@link Command} instance to retrieve default argument values for.
+     */
+    async getDefaultArgumentValues(cliConfig, command) {
+        if (!this.configEnabled) {
+            logger.debug("configuration of default values is not enabled");
+            return undefined;
+        }
+        logger.debug("getting default argument values for command: %s", command.name);
+        if (command.enableConfiguration === undefined || command.enableConfiguration !== true) {
+            logger.debug("enableConfiguration for command: %s is not true", command.name);
+            return undefined;
+        }
+        let result;
+        if (isGlobalModifierCommand(command) || isGlobalCommand(command)) {
+            const configuredValue = this.defaultsData.get(command.name);
+            const envVarValue = this.envVarsEnabled
+                ? getGlobalCommandValueFromEnvVars(cliConfig, command)
+                : undefined;
+            // default to environment variable value
+            result = envVarValue !== undefined ? envVarValue : configuredValue;
+        }
+        else if (isSubCommand(command)) {
+            const configuredValues = this.defaultsData.get(command.name);
+            const envVarValues = this.envVarsEnabled
+                ? getSubCommandValuesFromEnvVars(cliConfig, command)
+                : undefined;
+            if (envVarValues === undefined) {
+                result = configuredValues;
+            }
+            else if (configuredValues === undefined) {
+                result = envVarValues;
+            }
+            else {
+                result = argumentValueMerge(envVarValues, configuredValues);
+            }
+        }
+        if (result !== undefined && this.#defaultSecretService) {
+            result = await this.#resolveSecrets(result);
+        }
+        return result;
+    }
+    async #resolveSecrets(value) {
+        if (typeof value === "string" && value.startsWith(SECRET_SENTINEL_PREFIX)) {
+            const bunSecretName = value.slice(SECRET_SENTINEL_PREFIX.length);
+            const secretValue = await this.#defaultSecretService.getSecret(bunSecretName);
+            if (secretValue === null) {
+                throw new Error(`Secret not found in OS secret store for sentinel: '${value}'`);
+            }
+            return secretValue;
+        }
+        if (typeof value === "object" && value !== null) {
+            if (Array.isArray(value)) {
+                const resolved = [];
+                for (const item of value) {
+                    resolved.push(await this.#resolveSecrets(item));
+                }
+                return resolved;
+            }
+            const resolved = {};
+            for (const [key, val] of Object.entries(value)) {
+                resolved[key] = await this.#resolveSecrets(val);
+            }
+            return resolved;
+        }
+        return value;
+    }
+    /**
+     * Indicate that the contained {@link DefaultKeyValueService} should be set to have a scope of the provided
+     * command name.
+     *
+     * @param commandName the name of the command to scope the key-value data to.
+     *
+     * @throws {Error} if an existing scope is set.
+     */
+    setCommandKeyValueScope(commandName) {
+        if (!this.keyValueServiceEnabled && !this.secretServiceEnabled) {
+            throw new Error(`Attempt to use KeyValueService/SecretService which is not enabled`);
+        }
+        if (this.#currentCommandNameKeyValueScope) {
+            throw new Error(`Attempt to set CommandNameKeyValueScope to ${commandName} when it is currently set to ${this.#currentCommandNameKeyValueScope}`);
+        }
+        if (this.#currentServiceIdKeyValueScope) {
+            throw new Error(`Attempt to set CommandNameKeyValueScope to ${commandName} when ServiceIdKeyValueScope is currently set to ${this.#currentCommandNameKeyValueScope}`);
+        }
+        this.#currentCommandNameKeyValueScope = commandName;
+        logger.debug("currentCommandNameKeyValueScope: %s", commandName);
+        if (this.#defaultKeyValueService) {
+            if (!this.#commandKeyValueData.has(commandName)) {
+                this.#commandKeyValueData.set(commandName, new Map());
+            }
+            this.#defaultKeyValueService.setKeyValueData(this.#commandKeyValueData.get(commandName));
+        }
+        if (this.#defaultSecretService) {
+            this.#defaultSecretService.setScope("command_" + commandName);
+        }
+    }
+    /**
+     * Indicate that the contained {@link DefaultKeyValueService} should be set to have a scope of the provided
+     * service ID.
+     *
+     * @param serviceId the ID of the service to scope the key-value data to.
+     *
+     * @throws {Error} if an existing scope is set.
+     */
+    setServiceKeyValueScope(serviceId) {
+        if (!this.keyValueServiceEnabled && !this.secretServiceEnabled) {
+            throw new Error(`Attempt to use KeyValueService/SecretService which is not enabled`);
+        }
+        if (this.#currentServiceIdKeyValueScope) {
+            throw new Error(`Attempt to set ServiceIdKeyValueScope to ${serviceId} when it is currently set to ${this.#currentServiceIdKeyValueScope}`);
+        }
+        if (this.#currentCommandNameKeyValueScope) {
+            throw new Error(`Attempt to set ServiceIdKeyValueScope to ${serviceId} when CommandNameKeyValueScope is currently set to ${this.#currentServiceIdKeyValueScope}`);
+        }
+        this.#currentServiceIdKeyValueScope = serviceId;
+        logger.debug("currentServiceIdKeyValueScope: %s", serviceId);
+        if (this.#defaultKeyValueService) {
+            if (!this.#serviceKeyValueData.has(serviceId)) {
+                this.#serviceKeyValueData.set(serviceId, new Map());
+            }
+            this.#defaultKeyValueService.setKeyValueData(this.#serviceKeyValueData.get(serviceId));
+        }
+        if (this.#defaultSecretService) {
+            this.#defaultSecretService.setScope("service_" + serviceId);
+        }
+    }
+    /**
+     * Indicate that the contained {@link DefaultKeyValueService} should have any current scope cleared.
+     *
+     * If a scope is currently set and changes have been made to the key-value data, they will be written
+     * to the current configuration location.
+     */
+    async clearKeyValueScope() {
+        if (!this.keyValueServiceEnabled && !this.secretServiceEnabled) {
+            throw new Error(`Attempt to use KeyValueService/SecretService which is not enabled`);
+        }
+        if (this.#defaultKeyValueService && this.#defaultKeyValueService.isDirty()) {
+            if (this.configLocation === undefined) {
+                throw new Error("Attempt to write updated config with no configLocation set");
+            }
+            await this.#writeConfig(this.configLocation);
+        }
+        this.#currentCommandNameKeyValueScope = undefined;
+        this.#currentServiceIdKeyValueScope = undefined;
+        if (this.#defaultKeyValueService) {
+            this.#defaultKeyValueService.clearKeyValueData();
+        }
+        if (this.#defaultSecretService) {
+            this.#defaultSecretService.clearScope();
+        }
+    }
+    async initService(context) {
+        if (!this.configEnabled) {
+            return;
+        }
+        let isDefault = false;
+        if (this.configLocation === undefined) {
+            isDefault = true;
+            // default to `$HOME/.<application_name>.json`
+            const home = process.env["HOME"];
+            if (home) {
+                this.configLocation = path.join(home, `.${context.cliConfig.name.replace(/\W/g, "")}.json`);
+            }
+        }
+        if (this.configLocation === undefined) {
+            return;
+        }
+        let fileInfo;
+        try {
+            fileInfo = await fs.lstat(this.configLocation);
+        }
+        catch (err) {
+            const error = err;
+            if (isDefault) {
+                logger.debug("Default config file location: %s does not exist or is not visible - ignoring: %s", this.configLocation, error.message);
+                return;
+            }
+            else {
+                throw new Error(`Config file location: '${this.configLocation}' doesn't exist or not visible: ${error.message}`);
+            }
+        }
+        if (fileInfo.isDirectory()) {
+            throw new Error(`Config file location: '${this.configLocation}' is a directory and not a file!`);
+        }
+        await this.#readConfig(this.configLocation);
+    }
+    async #readConfig(location) {
+        try {
+            logger.debug("Reading config from: %s", location);
+            const data = await fs.readFile(location);
+            const config = JSON.parse(data.toString());
+            if (config === undefined) {
+                return;
+            }
+            this.defaultsData.clear();
+            this.#commandKeyValueData.clear();
+            this.#serviceKeyValueData.clear();
+            if (config.defaults !== undefined) {
+                const defaults = config.defaults;
+                Object.keys(defaults).forEach((commandName) => {
+                    this.defaultsData.set(commandName, defaults[commandName]);
+                    logger.debug("Set default argument values for command name: %s", commandName);
+                });
+            }
+            if (config["key-values"] !== undefined) {
+                const keyValues = config["key-values"];
+                if (keyValues.commands !== undefined) {
+                    const commandKeyValues = keyValues.commands;
+                    Object.keys(commandKeyValues).forEach((commandName) => {
+                        this.#commandKeyValueData.set(commandName, new Map(Object.entries(commandKeyValues[commandName])));
+                        logger.debug("Set default argument values for command name: %s", commandName);
+                    });
+                }
+                if (keyValues.services !== undefined) {
+                    const serviceKeyValues = keyValues.services;
+                    Object.keys(serviceKeyValues).forEach((serviceId) => {
+                        this.#serviceKeyValueData.set(serviceId, new Map(Object.entries(serviceKeyValues[serviceId])));
+                        logger.debug("Set default argument values for service ID: %s", serviceId);
+                    });
+                }
+            }
+        }
+        catch (err) {
+            throw new Error(`Failed to read config at location: '${this.configLocation}': ${err}`);
+        }
+    }
+    async #writeConfig(location) {
+        logger.debug("Writing config to: %s", location);
+        try {
+            await fs.writeFile(location, this.getConfigString());
+        }
+        catch (err) {
+            throw new Error(`Failed to write config at location: '${this.configLocation}': ${err}`);
+        }
+    }
+    getConfigString() {
+        const config = {};
+        if (this.defaultsData.size > 0) {
+            config.defaults = Object.fromEntries(this.defaultsData);
+        }
+        if (this.#commandKeyValueData.size > 0 || this.#serviceKeyValueData.size > 0) {
+            config["key-values"] = {};
+            if (this.#commandKeyValueData.size > 0) {
+                config["key-values"].commands = {};
+                for (const [commandName, keyValueData] of this.#commandKeyValueData.entries()) {
+                    if (keyValueData.size > 0) {
+                        config["key-values"].commands[commandName] = Object.fromEntries(keyValueData);
+                    }
+                }
+            }
+            if (this.#serviceKeyValueData.size > 0) {
+                config["key-values"].services = {};
+                for (const [serviceId, keyValueData] of this.#serviceKeyValueData.entries()) {
+                    if (keyValueData.size > 0) {
+                        config["key-values"].services[serviceId] = Object.fromEntries(keyValueData);
+                    }
+                }
+            }
+        }
+        return JSON.stringify(config, null, 2);
+    }
+}