@flowscripter/dynamic-cli-framework 2.4.0 → 3.0.0

package/src/runtime/values/subCommandValuePopulation.ts

@@ -1,11 +1,11 @@
 import type { Option } from "@flowscripter/dynamic-cli-framework-api";
 import type { SubCommand } from "@flowscripter/dynamic-cli-framework-api";
 import {
-  type ArgumentSingleValueType,
-  ArgumentValueTypeName,
-  type PopulatedArgumentSingleValueType,
-  type PopulatedArgumentValues,
-  type PopulatedArgumentValueType,
+  type SingleValueType,
+  ValueTypeName,
+  type PopulatedSingleValueType,
+  type PopulatedValues,
+  type PopulatedValueType,
 } from "@flowscripter/dynamic-cli-framework-api";
 import getLogger from "../../util/logger.ts";
 import argumentValueMerge from "./argumentValueMerge.ts";
@@ -58,7 +58,7 @@ class ParseContext {
   /**
    * The current populated values for the sub-command.
    */
-  populatedArgumentValues: PopulatedArgumentValues;
+  populatedArgumentValues: PopulatedValues;
 
   /**
    * Current parse state.
@@ -163,9 +163,9 @@ class ParseContext {
     const complexAndArrayPathElements: Array<string | number> = [];
     let option: Option | ComplexOption | undefined = undefined;
     let currentValue:
-      | PopulatedArgumentValues
-      | Array<PopulatedArgumentValues | PopulatedArgumentValueType>
-      | PopulatedArgumentValueType
+      | PopulatedValues
+      | Array<PopulatedValues | PopulatedValueType>
+      | PopulatedValueType
       | undefined = this.populatedArgumentValues;
 
     for (let i = 0; i < complexPathElements.length; i++) {
@@ -277,10 +277,10 @@ class ParseContext {
         return false;
       }
 
-      if ((currentValue as PopulatedArgumentValues)[complexPathElement] === undefined) {
+      if ((currentValue as PopulatedValues)[complexPathElement] === undefined) {
         // ensure we have a placeholder value
         if (option.isArray) {
-          currentValue = (currentValue as PopulatedArgumentValues)[complexPathElement] = [];
+          currentValue = (currentValue as PopulatedValues)[complexPathElement] = [];
 
           if (isComplexOption(option)) {
             // if we are retrieving a property by name only use the last entry in the array by default
@@ -292,12 +292,10 @@ class ParseContext {
             currentValue = currentValue[index] = {};
           }
         } else if (isComplexOption(option)) {
-          currentValue = (currentValue as PopulatedArgumentValues)[complexPathElement] = {};
+          currentValue = (currentValue as PopulatedValues)[complexPathElement] = {};
         }
       } else {
-        currentValue = (currentValue as PopulatedArgumentValues)[
-          complexPathElement
-        ] as PopulatedArgumentValues;
+        currentValue = (currentValue as PopulatedValues)[complexPathElement] as PopulatedValues;
         if (Array.isArray(currentValue)) {
           // if we are retrieving a property by name only use the last entry in the array by default
           // (this is the scenario when array indices are implicit)
@@ -354,11 +352,9 @@ class ParseContext {
    * @return `false` if there is a problem populating the value, in which case the {@link state} will be set to
    * {@link ParseState.ERROR} and {@link invalidArgument} will be populated.
    */
-  setOptionValue(value: ArgumentSingleValueType): boolean {
-    let optionValue:
-      | Array<PopulatedArgumentValues>
-      | PopulatedArgumentValues
-      | PopulatedArgumentValueType = this.populatedArgumentValues;
+  setOptionValue(value: SingleValueType): boolean {
+    let optionValue: Array<PopulatedValues> | PopulatedValues | PopulatedValueType =
+      this.populatedArgumentValues;
     const optionPath = this.currentOptionPath as Array<string | number>;
 
     // traverse the current populated values using the validated option path elements
@@ -368,11 +364,11 @@ class ParseContext {
       // if on last path element, set the value
       if (i === optionPath.length - 1) {
         if (typeof pathElement === "string") {
-          const currentValue = (optionValue as PopulatedArgumentValues)[pathElement as string];
+          const currentValue = (optionValue as PopulatedValues)[pathElement as string];
 
           // if we haven't populated the argument value before...
           if (currentValue === undefined) {
-            (optionValue as PopulatedArgumentValues)[pathElement as string] = value;
+            (optionValue as PopulatedValues)[pathElement as string] = value;
           } // if we have already populated the argument value as an array...
           else if (Array.isArray(currentValue)) {
             if (currentValue.length === MAXIMUM_ARGUMENT_ARRAY_SIZE) {
@@ -385,7 +381,7 @@ class ParseContext {
               return false;
             }
             // push the new value
-            (currentValue as Array<PopulatedArgumentSingleValueType>).push(value);
+            (currentValue as Array<PopulatedSingleValueType>).push(value);
           } // else the value to add would make an array where it is not allowed
           else {
             this.invalidArgument = {
@@ -398,30 +394,29 @@ class ParseContext {
           }
         } else {
           // set the new value on the array
-          (optionValue as Array<PopulatedArgumentValueType | PopulatedArgumentValues>)[
-            pathElement as number
-          ] = value;
+          (optionValue as Array<PopulatedValueType | PopulatedValues>)[pathElement as number] =
+            value;
         }
       } // otherwise continue to navigate the path
       else {
         if (typeof pathElement === "string") {
           if (Array.isArray(optionValue)) {
-            optionValue = (optionValue as Array<PopulatedArgumentValues>)[
-              (optionValue as Array<PopulatedArgumentValues>).length - 1
+            optionValue = (optionValue as Array<PopulatedValues>)[
+              (optionValue as Array<PopulatedValues>).length - 1
             ]![pathElement as string] as
-              | Array<PopulatedArgumentValues>
-              | PopulatedArgumentValues
-              | PopulatedArgumentValueType;
+              | Array<PopulatedValues>
+              | PopulatedValues
+              | PopulatedValueType;
           } else {
-            optionValue = (optionValue as PopulatedArgumentValues)[pathElement as string] as
-              | Array<PopulatedArgumentValues>
-              | PopulatedArgumentValues
-              | PopulatedArgumentValueType;
+            optionValue = (optionValue as PopulatedValues)[pathElement as string] as
+              | Array<PopulatedValues>
+              | PopulatedValues
+              | PopulatedValueType;
           }
         } else {
-          optionValue = (
-            optionValue as Array<PopulatedArgumentSingleValueType | PopulatedArgumentValues>
-          )[pathElement as number];
+          optionValue = (optionValue as Array<PopulatedSingleValueType | PopulatedValues>)[
+            pathElement as number
+          ];
         }
       }
     }
@@ -441,7 +436,7 @@ class ParseContext {
    *
    * @param value the value to attempt to set.
    */
-  setPositionalValue(value: ArgumentSingleValueType): boolean {
+  setPositionalValue(value: SingleValueType): boolean {
     const positional = this.subCommand.positionals[this.currentPositionalIndex]!;
     const currentValue = this.populatedArgumentValues[positional.name];
 
@@ -465,9 +460,9 @@ class ParseContext {
         return false;
       }
       this.populatedArgumentValues[positional.name] = [
-        ...(currentValue as Array<PopulatedArgumentSingleValueType>),
+        ...(currentValue as Array<PopulatedSingleValueType>),
         value,
-      ] as Array<PopulatedArgumentSingleValueType>;
+      ] as Array<PopulatedSingleValueType>;
     }
 
     // Update the state
@@ -493,7 +488,7 @@ class ParseContext {
       if (
         potentialArg !== "true" &&
         potentialArg !== "false" &&
-        this.currentOption!.type === ArgumentValueTypeName.BOOLEAN
+        this.currentOption!.type === ValueTypeName.BOOLEAN
       ) {
         // Set the value to implicit value of true and return ony error.
         if (!this.setOptionValue("true")) {
@@ -582,16 +577,16 @@ class ParseContext {
 }
 
 /**
- * Populate {@link PopulatedArgumentValues} for the provided {@link SubCommand} using the provided potential args.
+ * Populate {@link PopulatedValues} for the provided {@link SubCommand} using the provided potential args.
  *
- * @param subCommand the {@link SubCommand} for which {@link PopulatedArgumentValues} values should be populated.
+ * @param subCommand the {@link SubCommand} for which {@link PopulatedValues} values should be populated.
  * @param potentialArgs the potential args to use for population.
- * @param defaultValues optional default {@link ArgumentValues} to use for population before parsing the provided arguments.
+ * @param defaultValues optional default {@link Values} to use for population before parsing the provided arguments.
  */
 export default function populateSubCommandValues(
   subCommand: SubCommand,
   potentialArgs: ReadonlyArray<string>,
-  defaultValues: PopulatedArgumentValues | undefined,
+  defaultValues: PopulatedValues | undefined,
 ): SubCommandValuePopulationResult {
   logger.debug(() => {
     const message = `Populating values for sub-command: '${subCommand.name}' using potential args: ${potentialArgs.join(
@@ -629,7 +624,7 @@ export default function populateSubCommandValues(
   // Check if the last arg specified an option but no value
   if (parseContext.state === ParseState.OPTION_VALUE_EXPECTED) {
     // special case if the last arg was for a boolean option where the value was implicitly `true`
-    if (parseContext.currentOption!.type === ArgumentValueTypeName.BOOLEAN) {
+    if (parseContext.currentOption!.type === ValueTypeName.BOOLEAN) {
       parseContext.setOptionValue("true");
     } else {
       parseContext.invalidArgument = {

package/src/service/argumentPrompter/DefaultArgumentPrompterService.ts

@@ -9,11 +9,11 @@ import {
 import { InvalidArgumentReason } from "@flowscripter/dynamic-cli-framework-api";
 import type { InvalidArgument } from "@flowscripter/dynamic-cli-framework-api";
 import {
-  type ArgumentSingleValueType,
-  ArgumentValueTypeName,
+  type SingleValueType,
+  ValueTypeName,
   ComplexValueTypeName,
-  type PopulatedArgumentSingleValueType,
-  type PopulatedArgumentValues,
+  type PopulatedSingleValueType,
+  type PopulatedValues,
 } from "@flowscripter/dynamic-cli-framework-api";
 import type { Argument } from "@flowscripter/dynamic-cli-framework-api";
 import type { Option } from "@flowscripter/dynamic-cli-framework-api";
@@ -76,14 +76,14 @@ export default class DefaultArgumentPrompterService implements ArgumentPrompterS
     );
     const result = await this.#prompterService.prompt(prompt);
     const value = DefaultArgumentPrompterService.#coerceValue(
-      result.value as ArgumentSingleValueType,
+      result.value as SingleValueType,
       command.argument.type,
     );
 
     return {
       command: parseResult.command,
       groupCommand: parseResult.groupCommand,
-      populatedArgumentValues: value as PopulatedArgumentSingleValueType,
+      populatedArgumentValues: value as PopulatedSingleValueType,
       invalidArguments: [],
       unusedArgs: parseResult.unusedArgs,
     };
@@ -91,8 +91,8 @@ export default class DefaultArgumentPrompterService implements ArgumentPrompterS
 
   async #promptForSubCommand(parseResult: ParseResult): Promise<ParseResult> {
     const command = parseResult.command as SubCommand;
-    const existingValues = (parseResult.populatedArgumentValues ?? {}) as PopulatedArgumentValues;
-    const newValues: Record<string, PopulatedArgumentValues[string]> = {
+    const existingValues = (parseResult.populatedArgumentValues ?? {}) as PopulatedValues;
+    const newValues: Record<string, PopulatedValues[string]> = {
       ...existingValues,
     };
     const remainingInvalid: InvalidArgument[] = [];
@@ -129,7 +129,7 @@ export default class DefaultArgumentPrompterService implements ArgumentPrompterS
         );
         const result = await this.#prompterService.prompt(prompt);
         newValues[invalid.name] = DefaultArgumentPrompterService.#coerceValue(
-          result.value as ArgumentSingleValueType,
+          result.value as SingleValueType,
           (arg as Argument).type,
         );
       }
@@ -138,7 +138,7 @@ export default class DefaultArgumentPrompterService implements ArgumentPrompterS
     return {
       command: parseResult.command,
       groupCommand: parseResult.groupCommand,
-      populatedArgumentValues: newValues as PopulatedArgumentValues,
+      populatedArgumentValues: newValues as PopulatedValues,
       invalidArguments: remainingInvalid,
       unusedArgs: parseResult.unusedArgs,
     };
@@ -147,8 +147,8 @@ export default class DefaultArgumentPrompterService implements ArgumentPrompterS
   async #promptForComplexOption(
     name: string,
     complexOption: ComplexOption,
-  ): Promise<PopulatedArgumentValues> {
-    const values: Record<string, PopulatedArgumentValues[string]> = {};
+  ): Promise<PopulatedValues> {
+    const values: Record<string, PopulatedValues[string]> = {};
 
     for (const prop of complexOption.properties) {
       if ("type" in prop && (prop as ComplexOption).type === ComplexValueTypeName.COMPLEX) {
@@ -168,20 +168,20 @@ export default class DefaultArgumentPrompterService implements ArgumentPrompterS
         );
         const result = await this.#prompterService.prompt(prompt);
         values[option.name] = DefaultArgumentPrompterService.#coerceValue(
-          result.value as ArgumentSingleValueType,
+          result.value as SingleValueType,
           option.type,
         );
       }
     }
 
-    return values as PopulatedArgumentValues;
+    return values as PopulatedValues;
   }
 
   async #promptForArrayArgument(
     name: string,
     arg: Option | Positional,
-  ): Promise<Array<ArgumentSingleValueType>> {
-    const values: ArgumentSingleValueType[] = [];
+  ): Promise<Array<SingleValueType>> {
+    const values: SingleValueType[] = [];
 
     while (true) {
       const prompt = DefaultArgumentPrompterService.#argumentToPrompt(
@@ -192,7 +192,7 @@ export default class DefaultArgumentPrompterService implements ArgumentPrompterS
       const result = await this.#prompterService.prompt(prompt);
       values.push(
         DefaultArgumentPrompterService.#coerceValue(
-          result.value as ArgumentSingleValueType,
+          result.value as SingleValueType,
           (arg as Argument).type,
         ),
       );
@@ -213,7 +213,7 @@ export default class DefaultArgumentPrompterService implements ArgumentPrompterS
   }
 
   static #argumentToPrompt(name: string, description: string, arg: Argument): Prompt {
-    if (arg.type === ArgumentValueTypeName.BOOLEAN) {
+    if (arg.type === ValueTypeName.BOOLEAN) {
       return {
         name,
         promptText: description,
@@ -236,7 +236,7 @@ export default class DefaultArgumentPrompterService implements ArgumentPrompterS
     }
 
     const validationOption: PromptOption = {
-      displayValue: arg.type === ArgumentValueTypeName.SECRET ? "__SECRET__" : name,
+      displayValue: arg.type === ValueTypeName.SECRET ? "__SECRET__" : name,
       returnedValue: "",
       min: arg.minValueInclusive,
       max: arg.maxValueInclusive,
@@ -251,17 +251,14 @@ export default class DefaultArgumentPrompterService implements ArgumentPrompterS
     };
   }
 
-  static #coerceValue(
-    value: ArgumentSingleValueType,
-    type: ArgumentValueTypeName,
-  ): ArgumentSingleValueType {
+  static #coerceValue(value: SingleValueType, type: ValueTypeName): SingleValueType {
     if (typeof value === "string") {
       switch (type) {
-        case ArgumentValueTypeName.INTEGER:
+        case ValueTypeName.INTEGER:
           return parseInt(value, 10);
-        case ArgumentValueTypeName.NUMBER:
+        case ValueTypeName.NUMBER:
           return parseFloat(value);
-        case ArgumentValueTypeName.BOOLEAN:
+        case ValueTypeName.BOOLEAN:
           return value.toLowerCase() === "true";
       }
     }

package/src/service/banner/command/NoBannerCommand.ts

@@ -1,8 +1,5 @@
 import type { GlobalModifierCommand } from "@flowscripter/dynamic-cli-framework-api";
-import {
-  type ArgumentSingleValueType,
-  ArgumentValueTypeName,
-} from "@flowscripter/dynamic-cli-framework-api";
+import { type SingleValueType, ValueTypeName } from "@flowscripter/dynamic-cli-framework-api";
 import type { Context } from "@flowscripter/dynamic-cli-framework-api";
 import type { GlobalCommandArgument } from "@flowscripter/dynamic-cli-framework-api";
 import type BannerServiceProvider from "../BannerServiceProvider.ts";
@@ -15,7 +12,7 @@ export default class NoBannerCommand implements GlobalModifierCommand {
   readonly description = "Disable output of banner";
   readonly enableConfiguration = true;
   readonly argument: GlobalCommandArgument = {
-    type: ArgumentValueTypeName.BOOLEAN,
+    type: ValueTypeName.BOOLEAN,
     defaultValue: true,
     configurationKey: "NO_BANNER",
   };
@@ -28,7 +25,7 @@ export default class NoBannerCommand implements GlobalModifierCommand {
     this.executePriority = executePriority;
   }
 
-  public execute(_context: Context, argumentValue: ArgumentSingleValueType): Promise<void> {
+  public execute(_context: Context, argumentValue: SingleValueType): Promise<void> {
     this.#bannerServiceProvider.printBanner = !(argumentValue as boolean);
 
     return Promise.resolve();

package/src/service/completion/command/CompletionCompleteSubCommand.ts

@@ -2,10 +2,7 @@ import type { SubCommand } from "@flowscripter/dynamic-cli-framework-api";
 import type { Option } from "@flowscripter/dynamic-cli-framework-api";
 import type { Positional } from "@flowscripter/dynamic-cli-framework-api";
 import type { Context } from "@flowscripter/dynamic-cli-framework-api";
-import {
-  type ArgumentValues,
-  ArgumentValueTypeName,
-} from "@flowscripter/dynamic-cli-framework-api";
+import { type Values, ValueTypeName } from "@flowscripter/dynamic-cli-framework-api";
 import { COMPLETION_SERVICE_ID, ShellType } from "@flowscripter/dynamic-cli-framework-api";
 import type DefaultCompletionService from "../DefaultCompletionService.ts";
 import { PRINTER_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
@@ -22,20 +19,20 @@ export class CompletionCompleteSubCommand implements SubCommand {
   readonly positionals: ReadonlyArray<Positional> = [
     {
       name: "shell",
-      type: ArgumentValueTypeName.STRING,
+      type: ValueTypeName.STRING,
       allowableValues: Object.values(ShellType),
       description: "Shell type",
     },
     {
       name: "args",
-      type: ArgumentValueTypeName.STRING,
+      type: ValueTypeName.STRING,
       isVarargMultiple: true,
       isVarargOptional: true,
       description: "Shell-specific completion context arguments",
     },
   ];
 
-  async execute(context: Context, argumentValues: ArgumentValues): Promise<void> {
+  async execute(context: Context, argumentValues: Values): Promise<void> {
     const completionService = context.getServiceById(
       COMPLETION_SERVICE_ID,
     ) as DefaultCompletionService;

package/src/service/completion/command/CompletionIntegrationSubCommand.ts

@@ -3,10 +3,7 @@ import type { SubCommand } from "@flowscripter/dynamic-cli-framework-api";
 import type { Option } from "@flowscripter/dynamic-cli-framework-api";
 import type { Positional } from "@flowscripter/dynamic-cli-framework-api";
 import type { Context } from "@flowscripter/dynamic-cli-framework-api";
-import {
-  type ArgumentValues,
-  ArgumentValueTypeName,
-} from "@flowscripter/dynamic-cli-framework-api";
+import { type Values, ValueTypeName } from "@flowscripter/dynamic-cli-framework-api";
 import { COMPLETION_SERVICE_ID, ShellType } from "@flowscripter/dynamic-cli-framework-api";
 import type DefaultCompletionService from "../DefaultCompletionService.ts";
 import { Icon, PRINTER_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
@@ -20,7 +17,7 @@ export class CompletionIntegrationSubCommand implements SubCommand {
   readonly options: ReadonlyArray<Option> = [
     {
       name: "config-path",
-      type: ArgumentValueTypeName.STRING,
+      type: ValueTypeName.STRING,
       isOptional: true,
       description: "Path to shell configuration file",
     },
@@ -29,13 +26,13 @@ export class CompletionIntegrationSubCommand implements SubCommand {
   readonly positionals: ReadonlyArray<Positional> = [
     {
       name: "shell",
-      type: ArgumentValueTypeName.STRING,
+      type: ValueTypeName.STRING,
       allowableValues: Object.values(ShellType),
       description: "Shell type to configure",
     },
   ];
 
-  async execute(context: Context, argumentValues: ArgumentValues): Promise<void> {
+  async execute(context: Context, argumentValues: Values): Promise<void> {
     const completionService = context.getServiceById(
       COMPLETION_SERVICE_ID,
     ) as DefaultCompletionService;

package/src/service/configuration/ConfigurationServiceProvider.ts

@@ -5,10 +5,10 @@ import { Stats } from "node:fs";
 import type { ServiceInfo, ServiceProvider } from "@flowscripter/dynamic-cli-framework-api";
 import ConfigCommand from "./command/ConfigCommand.ts";
 import type {
-  ArgumentSingleValueType,
-  ArgumentValues,
-  PopulatedArgumentValues,
-  PopulatedArgumentValueType,
+  SingleValueType,
+  Values,
+  PopulatedValues,
+  PopulatedValueType,
 } from "@flowscripter/dynamic-cli-framework-api";
 import getLogger from "../../util/logger.ts";
 import type { Context } from "@flowscripter/dynamic-cli-framework-api";
@@ -42,16 +42,16 @@ const logger = getLogger("ConfigurationServiceProvider");
  *
  * **Default Command Arguments**
  *
- * Configuration of default {@link ArgumentValues} for {@link Command} instances is supported if they
+ * Configuration of default {@link Values} 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
+ * A JSON file where the structure matches {@link Values} 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:
+ * and the contained values are treated as command {@link Values}. As an example:
  *
  * ```
  * {
@@ -178,9 +178,9 @@ export default class ConfigurationServiceProvider implements ServiceProvider {
   public configLocation: string | undefined;
 
   // the configuration data to be used by the CLI runner implementation when setting command defaults.
-  // ArgumentSingleValueType is for GlobalCommandArgument values, ArgumentValues is for
+  // SingleValueType is for GlobalCommandArgument values, Values is for
   // SubCommandArgument values.
-  public defaultsData: Map<string, ArgumentValues | ArgumentSingleValueType> = new Map();
+  public defaultsData: Map<string, Values | SingleValueType> = 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.
@@ -264,7 +264,7 @@ export default class ConfigurationServiceProvider implements ServiceProvider {
   public async getDefaultArgumentValues(
     cliConfig: CLIConfig,
     command: Command,
-  ): Promise<PopulatedArgumentValues | PopulatedArgumentValueType | undefined> {
+  ): Promise<PopulatedValues | PopulatedValueType | undefined> {
     if (!this.configEnabled) {
       logger.debug("configuration of default values is not enabled");
       return undefined;
@@ -277,17 +277,17 @@ export default class ConfigurationServiceProvider implements ServiceProvider {
       return undefined;
     }
 
-    let result: PopulatedArgumentValues | PopulatedArgumentValueType | undefined;
+    let result: PopulatedValues | PopulatedValueType | undefined;
 
     if (isGlobalModifierCommand(command) || isGlobalCommand(command)) {
-      const configuredValue = this.defaultsData.get(command.name) as ArgumentSingleValueType;
+      const configuredValue = this.defaultsData.get(command.name) as SingleValueType;
       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) as ArgumentValues;
+      const configuredValues = this.defaultsData.get(command.name) as Values;
       const envVarValues = this.envVarsEnabled
         ? getSubCommandValuesFromEnvVars(cliConfig, command)
         : undefined;
@@ -296,7 +296,7 @@ export default class ConfigurationServiceProvider implements ServiceProvider {
       } else if (configuredValues === undefined) {
         result = envVarValues;
       } else {
-        result = argumentValueMerge(envVarValues, configuredValues) as PopulatedArgumentValues;
+        result = argumentValueMerge(envVarValues, configuredValues) as PopulatedValues;
       }
     }
 
@@ -308,8 +308,8 @@ export default class ConfigurationServiceProvider implements ServiceProvider {
   }
 
   async #resolveSecrets(
-    value: PopulatedArgumentValues | PopulatedArgumentValueType,
-  ): Promise<PopulatedArgumentValues | PopulatedArgumentValueType> {
+    value: PopulatedValues | PopulatedValueType,
+  ): Promise<PopulatedValues | PopulatedValueType> {
     if (typeof value === "string" && value.startsWith(SECRET_SENTINEL_PREFIX)) {
       const bunSecretName = value.slice(SECRET_SENTINEL_PREFIX.length);
       const secretValue = await this.#defaultSecretService!.getSecret(bunSecretName);
@@ -324,13 +324,13 @@ export default class ConfigurationServiceProvider implements ServiceProvider {
         for (const item of value) {
           resolved.push(await this.#resolveSecrets(item));
         }
-        return resolved as unknown as PopulatedArgumentValues;
+        return resolved as unknown as PopulatedValues;
       }
       const resolved: Record<string, unknown> = {};
       for (const [key, val] of Object.entries(value)) {
-        resolved[key] = await this.#resolveSecrets(val as PopulatedArgumentValueType);
+        resolved[key] = await this.#resolveSecrets(val as PopulatedValueType);
       }
-      return resolved as unknown as PopulatedArgumentValues;
+      return resolved as unknown as PopulatedValues;
     }
     return value;
   }
@@ -496,7 +496,7 @@ export default class ConfigurationServiceProvider implements ServiceProvider {
       if (config.defaults !== undefined) {
         const defaults = config.defaults;
         Object.keys(defaults).forEach((commandName) => {
-          this.defaultsData.set(commandName, defaults[commandName] as ArgumentValues);
+          this.defaultsData.set(commandName, defaults[commandName] as Values);
           logger.debug("Set default argument values for command name: %s", commandName);
         });
       }
@@ -540,7 +540,7 @@ export default class ConfigurationServiceProvider implements ServiceProvider {
 
   public getConfigString(): string {
     const config: {
-      defaults?: Record<string, ArgumentValues | ArgumentSingleValueType>;
+      defaults?: Record<string, Values | SingleValueType>;
       "key-values"?: {
         commands?: Record<string, Record<string, string>>;
         services?: Record<string, Record<string, string>>;

package/src/service/configuration/command/ConfigCommand.ts

@@ -1,9 +1,6 @@
 import type { GlobalModifierCommand } from "@flowscripter/dynamic-cli-framework-api";
 import type { GlobalCommandArgument } from "@flowscripter/dynamic-cli-framework-api";
-import {
-  type ArgumentSingleValueType,
-  ArgumentValueTypeName,
-} from "@flowscripter/dynamic-cli-framework-api";
+import { type SingleValueType, ValueTypeName } from "@flowscripter/dynamic-cli-framework-api";
 import type { Context } from "@flowscripter/dynamic-cli-framework-api";
 import type ConfigurationServiceProvider from "../ConfigurationServiceProvider.ts";
 
@@ -15,7 +12,7 @@ export default class ConfigCommand implements GlobalModifierCommand {
   readonly description = "Set the configuration file location";
   readonly enableConfiguration = true;
   readonly argument: GlobalCommandArgument = {
-    type: ArgumentValueTypeName.STRING,
+    type: ValueTypeName.STRING,
     configurationKey: "CONFIG",
   };
   readonly executePriority: number;
@@ -30,7 +27,7 @@ export default class ConfigCommand implements GlobalModifierCommand {
     this.executePriority = executePriority;
   }
 
-  public execute(_context: Context, argumentValue: ArgumentSingleValueType): Promise<void> {
+  public execute(_context: Context, argumentValue: SingleValueType): Promise<void> {
     const configLocation = argumentValue as string;
 
     this.#configurationServiceProvider.setConfigLocation(configLocation);

package/src/service/fetch/DefaultFetchService.ts

@@ -0,0 +1,55 @@
+import type {
+  FetchOptions,
+  FetchService,
+  ShutdownService,
+} from "@flowscripter/dynamic-cli-framework-api";
+import getLogger from "../../util/logger.ts";
+
+const logger = getLogger("DefaultFetchService");
+
+export default class DefaultFetchService implements FetchService {
+  #shutdownService: ShutdownService | undefined;
+
+  public setDependencies(shutdownService: ShutdownService): void {
+    this.#shutdownService = shutdownService;
+  }
+
+  public async fetch(input: string | URL, options: FetchOptions = {}): Promise<Response> {
+    if (this.#shutdownService === undefined) {
+      throw new Error("DefaultFetchService.fetch() called before setDependencies()");
+    }
+    const shutdownService = this.#shutdownService;
+    const { timeoutMs, longRunning = false, signal: callerSignal, ...requestInit } = options;
+
+    const controller = new AbortController();
+    const signals: AbortSignal[] = [controller.signal];
+    if (callerSignal) {
+      signals.push(callerSignal);
+    }
+    if (timeoutMs !== undefined) {
+      signals.push(AbortSignal.timeout(timeoutMs));
+    }
+    const signal = signals.length === 1 ? signals[0]! : AbortSignal.any(signals);
+
+    let settled = false;
+    if (longRunning) {
+      shutdownService.enterLongRunningMode();
+      shutdownService.addShutdownListener(async () => {
+        if (settled) {
+          return;
+        }
+        logger.debug(() => `Aborting fetch of '${input.toString()}' due to shutdown`);
+        controller.abort();
+      });
+    }
+
+    try {
+      return await fetch(input, { ...requestInit, signal });
+    } finally {
+      settled = true;
+      if (longRunning) {
+        shutdownService.leaveLongRunningMode();
+      }
+    }
+  }
+}