@flowscripter/dynamic-cli-framework 9.1.3 → 10.1.0

package/dist/src/command/MultiCommandCliHelpCommand.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MultiCommandCliHelpCommand.d.ts","sourceRoot":"","sources":["../../../src/command/MultiCommandCliHelpCommand.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yCAAyC,CAAC;AAC1E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,yCAAyC,CAAC;AACtE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yCAAyC,CAAC;AAC1E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yCAAyC,CAAC;AAE7E,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,MAAM,EACX,aAAa,EACd,MAAM,yCAAyC,CAAC;AACjD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yCAAyC,CAAC;AAYvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAM/E;;GAEG;AACH,uBAAe,kCAAkC;;IAC/C,QAAQ,CAAC,IAAI,UAAU;IACvB,QAAQ,CAAC,WAAW,8BAA8B;IAIlD,YAAY,cAAc,EAAE,OAAO,EAAE,eAAe,EAAE,eAAe,EAGpE;IA8HD,UAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CA6ChE;IAED,UAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAmFnF;CACF;AAED;;GAEG;AACH,qBAAa,gCACX,SAAQ,kCACR,YAAW,aAAa;IAExB,QAAQ,CAAC,UAAU,OAAO;IAE1B,QAAQ,CAAC,QAAQ;;;;MAIf;IAEW,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,aAAa,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAOrF;CACF;AAED;;GAEG;AACH,qBAAa,6BACX,SAAQ,kCACR,YAAW,UAAU;IAErB,SAAgB,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,CAAM;IAEpD,SAAgB,WAAW,EAAE,aAAa,CAAC,UAAU,CAAC,CAOpD;IAEW,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAO5E;CACF"}
+{"version":3,"file":"MultiCommandCliHelpCommand.d.ts","sourceRoot":"","sources":["../../../src/command/MultiCommandCliHelpCommand.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yCAAyC,CAAC;AAC1E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,yCAAyC,CAAC;AACtE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yCAAyC,CAAC;AAC1E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yCAAyC,CAAC;AAE7E,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,MAAM,EACX,aAAa,EACd,MAAM,yCAAyC,CAAC;AACjD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yCAAyC,CAAC;AAYvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAM/E;;GAEG;AACH,uBAAe,kCAAkC;;IAC/C,QAAQ,CAAC,IAAI,UAAU;IACvB,QAAQ,CAAC,WAAW,8BAA8B;IAIlD,YAAY,cAAc,EAAE,OAAO,EAAE,eAAe,EAAE,eAAe,EAGpE;IA8HD,UAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CA6ChE;IAED,UAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAyFnF;CACF;AAED;;GAEG;AACH,qBAAa,gCACX,SAAQ,kCACR,YAAW,aAAa;IAExB,QAAQ,CAAC,UAAU,OAAO;IAE1B,QAAQ,CAAC,QAAQ;;;;MAIf;IAEW,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,aAAa,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAOrF;CACF;AAED;;GAEG;AACH,qBAAa,6BACX,SAAQ,kCACR,YAAW,UAAU;IAErB,SAAgB,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,CAAM;IAEpD,SAAgB,WAAW,EAAE,aAAa,CAAC,UAAU,CAAC,CAOpD;IAEW,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAO5E;CACF"}

package/dist/src/command/MultiCommandCliHelpCommand.js

@@ -188,7 +188,7 @@ class MultiCommandCliAbstractHelpCommand {
                 },
             ],
         });
-        helpSections.push(...getCommandArgsHelpSections(context.cliConfig, this.#includeEnvVars, subCommand, false));
+        helpSections.push(...getCommandArgsHelpSections(context.cliConfig, this.#includeEnvVars, subCommand, false, groupCommand));
         helpSections.push(...getCommandExamplesHelpSections(printerService, context, subCommand));
         await printHelpSections(printerService, tableGeneratorService, helpSections);
     }

package/dist/src/runtime/command/CommandValidator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CommandValidator.d.ts","sourceRoot":"","sources":["../../../../src/runtime/command/CommandValidator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yCAAyC,CAAC;AAiBvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAmJzE,MAAM,CAAC,OAAO,OAAO,gBAAgB;;IAInC,YAAmB,SAAS,EAAE,SAAS,EAEtC;IAED;;;;;;OAMG;IACI,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAUtC;CAgWF"}
+{"version":3,"file":"CommandValidator.d.ts","sourceRoot":"","sources":["../../../../src/runtime/command/CommandValidator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yCAAyC,CAAC;AAiBvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAmJzE,MAAM,CAAC,OAAO,OAAO,gBAAgB;;IAKnC,YAAmB,SAAS,EAAE,SAAS,EAEtC;IAED;;;;;;OAMG;IACI,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAUtC;CAsWF"}

package/dist/src/runtime/command/CommandValidator.js

@@ -97,6 +97,7 @@ function validateSubCommandArgument(subCommandArgument) {
 export default class CommandValidator {
     #cliConfig;
     #configurationKeys = [];
+    #currentGroupCommand;
     constructor(cliConfig) {
         this.#cliConfig = cliConfig;
     }
@@ -184,7 +185,13 @@ export default class CommandValidator {
                 throw new Error(`Group command: '${groupCommand.name}' contains member sub-command with the same name`);
             }
             subCommandNames.push(subCommand.name);
-            this.#validateSubCommand(subCommand);
+            this.#currentGroupCommand = groupCommand;
+            try {
+                this.#validateSubCommand(subCommand);
+            }
+            finally {
+                this.#currentGroupCommand = undefined;
+            }
         });
     }
     /**
@@ -254,7 +261,7 @@ export default class CommandValidator {
                 !isConfigurationKeyLegal(argument.configurationKey)) {
                 throw new Error(`Illegal configuration key: '${argument.configurationKey}'`);
             }
-            const configurationKey = getSubCommandArgumentConfigurationKey(this.#cliConfig, command, argumentAncestry);
+            const configurationKey = getSubCommandArgumentConfigurationKey(this.#cliConfig, command, argumentAncestry, this.#currentGroupCommand);
             if (configurationKey !== undefined) {
                 if (this.#configurationKeys.includes(configurationKey)) {
                     throw new Error(`Command: '${command.name}' contains arguments with the same configuration key: '${configurationKey}'`);

package/dist/src/runtime/parser.d.ts

@@ -2,18 +2,24 @@ import type { PopulatedSingleValueType, PopulatedValues } from "@flowscripter/dy
 import type { ParseResult } from "@flowscripter/dynamic-cli-framework-api";
 import type { CommandClause } from "./scanner.ts";
 export type { ParseResult } from "@flowscripter/dynamic-cli-framework-api";
+/**
+ * A {@link ParseResult} which also reports any SECRET arguments supplied as plain command line arguments.
+ */
+export type SecretAwareParseResult = ParseResult & {
+    readonly secretArgumentNames?: ReadonlyArray<string>;
+};
 /**
  * Parse the arguments for the specified {@link CommandClause} assuming it contains a {@link SubCommand}.
  *
  * @param commandClause the clause to parse.
  * @param defaultValues optional default {@link PopulatedValues} to use for population before parsing the provided arguments.
  */
-export declare function parseSubCommandClause(commandClause: CommandClause, defaultValues?: PopulatedValues): ParseResult;
+export declare function parseSubCommandClause(commandClause: CommandClause, defaultValues?: PopulatedValues): SecretAwareParseResult;
 /**
  * Parse the arguments for the specified {@link CommandClause} assuming it contains a {@link GlobalCommand} or {@link GlobalModifierCommand}.
  *
  * @param commandClause the clause to parse.
  * @param defaultValue optional default {@link PopulatedSingleValueType} to use for population before parsing the provided arguments.
  */
-export declare function parseGlobalCommandClause(commandClause: CommandClause, defaultValue?: PopulatedSingleValueType): ParseResult;
+export declare function parseGlobalCommandClause(commandClause: CommandClause, defaultValue?: PopulatedSingleValueType): SecretAwareParseResult;
 //# sourceMappingURL=parser.d.ts.map

package/dist/src/runtime/parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../../src/runtime/parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,wBAAwB,EACxB,eAAe,EAChB,MAAM,yCAAyC,CAAC;AAEjD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yCAAyC,CAAC;AAC3E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAclD,YAAY,EAAE,WAAW,EAAE,MAAM,yCAAyC,CAAC;AAE3E;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,aAAa,EAAE,aAAa,EAC5B,aAAa,CAAC,EAAE,eAAe,GAC9B,WAAW,CAiFb;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,aAAa,EAAE,aAAa,EAC5B,YAAY,CAAC,EAAE,wBAAwB,GACtC,WAAW,CA0Db"}
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../../src/runtime/parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,wBAAwB,EACxB,eAAe,EAChB,MAAM,yCAAyC,CAAC;AAEjD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yCAAyC,CAAC;AAC3E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAelD,YAAY,EAAE,WAAW,EAAE,MAAM,yCAAyC,CAAC;AAE3E;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG,WAAW,GAAG;IACjD,QAAQ,CAAC,mBAAmB,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CACtD,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,aAAa,EAAE,aAAa,EAC5B,aAAa,CAAC,EAAE,eAAe,GAC9B,sBAAsB,CAiFxB;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,aAAa,EAAE,aAAa,EAC5B,YAAY,CAAC,EAAE,wBAAwB,GACtC,sBAAsB,CAwDxB"}

package/dist/src/runtime/parser.js

@@ -1,6 +1,7 @@
 import populateGlobalCommandValue from "./values/globalCommandValuePopulation.js";
 import { validateGlobalCommandArgumentValue, validateOptionValue, validatePositionalValue, } from "./values/argumentValueValidation.js";
 import getLogger from "../util/logger.js";
+import { redactGlobalCommandValue, redactSubCommandValues } from "../util/secretRedaction.js";
 import populateSubCommandValues from "./values/subCommandValuePopulation.js";
 const logger = getLogger("parser");
 /**
@@ -24,7 +25,7 @@ export function parseSubCommandClause(commandClause, defaultValues) {
             unusedArgs: potentialArgs,
         };
     }
-    const { populatedArgumentValues, unusedArgs, invalidArgument } = populateSubCommandValues(command, potentialArgs, defaultValues);
+    const { populatedArgumentValues, unusedArgs, invalidArgument, secretArgumentNames } = populateSubCommandValues(command, potentialArgs, defaultValues);
     if (invalidArgument) {
         invalidArguments.push(invalidArgument);
     }
@@ -36,7 +37,7 @@ export function parseSubCommandClause(commandClause, defaultValues) {
                 populatedArgumentValues[option.name] = validatedValue;
             }
         });
-        logger.debug("Command arguments after options validated: %O with invalid args: %O", populatedArgumentValues, invalidArguments);
+        logger.debug("Command arguments after options validated: %O with invalid args: %O", redactSubCommandValues(command, populatedArgumentValues), invalidArguments);
         if (invalidArguments.length === 0) {
             // validate the positional values
             command.positionals.forEach((positional) => {
@@ -45,9 +46,10 @@ export function parseSubCommandClause(commandClause, defaultValues) {
                     populatedArgumentValues[positional.name] = validatedValue;
                 }
             });
-            logger.debug("Command arguments after positionals validated: %O with invalid args: %O", populatedArgumentValues, invalidArguments);
+            logger.debug("Command arguments after positionals validated: %O with invalid args: %O", redactSubCommandValues(command, populatedArgumentValues), invalidArguments);
         }
     }
+    const secrets = secretArgumentNames ? { secretArgumentNames } : {};
     if (groupCommand) {
         return {
             command,
@@ -55,6 +57,7 @@ export function parseSubCommandClause(commandClause, defaultValues) {
             groupCommand,
             invalidArguments,
             unusedArgs,
+            ...secrets,
         };
     }
     return {
@@ -62,6 +65,7 @@ export function parseSubCommandClause(commandClause, defaultValues) {
         populatedArgumentValues,
         invalidArguments,
         unusedArgs: unusedArgs,
+        ...secrets,
     };
 }
 /**
@@ -83,11 +87,11 @@ export function parseGlobalCommandClause(commandClause, defaultValue) {
             unusedArgs: potentialArgs,
         };
     }
-    let { populatedArgumentValue, unusedArgs, invalidArgument } = populateGlobalCommandValue(command, potentialArgs, defaultValue);
+    let { populatedArgumentValue, unusedArgs, invalidArgument, secretArgumentNames } = populateGlobalCommandValue(command, potentialArgs, defaultValue);
     if (invalidArgument) {
         invalidArguments.push(invalidArgument);
     }
-    logger.debug("Command arguments for command: %s after value population: %O with invalid args: %O and unused args: %O", command.name, populatedArgumentValue, invalidArguments, unusedArgs);
+    logger.debug("Command arguments for command: %s after value population: %O with invalid args: %O and unused args: %O", command.name, redactGlobalCommandValue(command, populatedArgumentValue), invalidArguments, unusedArgs);
     // don't validate the value if the argument is already invalid
     if (invalidArguments.length === 0) {
         const validatedValue = validateGlobalCommandArgumentValue(command, populatedArgumentValue, invalidArguments);
@@ -95,11 +99,12 @@ export function parseGlobalCommandClause(commandClause, defaultValue) {
             populatedArgumentValue = validatedValue;
         }
     }
-    logger.debug("Command arguments for command: %s after value validation: %O with invalid args: %O", command.name, populatedArgumentValue, invalidArguments);
+    logger.debug("Command arguments for command: %s after value validation: %O with invalid args: %O", command.name, redactGlobalCommandValue(command, populatedArgumentValue), invalidArguments);
     return {
         command,
         populatedArgumentValues: populatedArgumentValue,
         invalidArguments,
         unusedArgs,
+        ...(secretArgumentNames && { secretArgumentNames }),
     };
 }

package/dist/src/runtime/runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../../src/runtime/runner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEzE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAiB/E,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,yCAAyC,CAAC;AAEvF,OAAO,KAAK,4BAA4B,MAAM,0DAA0D,CAAC;AACzG,OAAO,KAAK,uBAAuB,MAAM,qDAAqD,CAAC;AAK/F,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yCAAyC,CAAC;AAKvE,OAAO,qBAAqB,MAAM,6CAA6C,CAAC;AAMhF;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG;IAAE,QAAQ,CAAC,aAAa,CAAC,EAAE,IAAI,CAAA;CAAE,CAAC;AAkfzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2EG;AACH,wBAAsB,GAAG,CACvB,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,EAC3B,eAAe,EAAE,eAAe,EAChC,uBAAuB,EAAE,uBAAuB,EAChD,4BAA4B,EAAE,4BAA4B,GAAG,SAAS,EACtE,uBAAuB,EAAE,uBAAuB,GAAG,SAAS,EAC5D,OAAO,EAAE,OAAO,EAChB,cAAc,CAAC,EAAE,OAAO,EACxB,cAAc,CAAC,EAAE,qBAAqB,GACrC,OAAO,CAAC,YAAY,CAAC,CAkKvB"}
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../../src/runtime/runner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEzE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAkB/E,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,yCAAyC,CAAC;AAEvF,OAAO,KAAK,4BAA4B,MAAM,0DAA0D,CAAC;AACzG,OAAO,KAAK,uBAAuB,MAAM,qDAAqD,CAAC;AAK/F,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yCAAyC,CAAC;AAKvE,OAAO,qBAAqB,MAAM,6CAA6C,CAAC;AAMhF;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG;IAAE,QAAQ,CAAC,aAAa,CAAC,EAAE,IAAI,CAAA;CAAE,CAAC;AAsfzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2EG;AACH,wBAAsB,GAAG,CACvB,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,EAC3B,eAAe,EAAE,eAAe,EAChC,uBAAuB,EAAE,uBAAuB,EAChD,4BAA4B,EAAE,4BAA4B,GAAG,SAAS,EACtE,uBAAuB,EAAE,uBAAuB,GAAG,SAAS,EAC5D,OAAO,EAAE,OAAO,EAChB,cAAc,CAAC,EAAE,OAAO,EACxB,cAAc,CAAC,EAAE,qBAAqB,GACrC,OAAO,CAAC,YAAY,CAAC,CAkKvB"}

package/dist/src/runtime/runner.js

@@ -1,7 +1,7 @@
 import { RunState } from "@flowscripter/dynamic-cli-framework-api";
 import { isGlobalCommand, isSubCommand } from "./command/CommandTypeGuards.js";
 import getLogger from "../util/logger.js";
-import { printCommandExecutionError, printNoCommandRecognisedError, printNoCommandSpecifiedError, printParseResultError, printUnusedArgsWarning, } from "../util/runnerHelper.js";
+import { printCommandExecutionError, printNoCommandRecognisedError, printNoCommandSpecifiedError, printParseResultError, printSecretArgsWarning, printUnusedArgsWarning, } from "../util/runnerHelper.js";
 import { scanForGlobalModifierCommandClauses, scanForNonModifierCommandClause } from "./scanner.js";
 import { parseGlobalCommandClause, parseSubCommandClause } from "./parser.js";
 import { ARGUMENT_PROMPTER_SERVICE_ID } from "@flowscripter/dynamic-cli-framework-api";
@@ -113,6 +113,7 @@ async function findAndExecuteGlobalModifierCommands(availableArgSequences, unuse
                 ? await configurationServiceProvider.getDefaultArgumentValues(context.cliConfig, globalModifierCommandClause.command)
                 : undefined;
             const parseResult = parseGlobalCommandClause(globalModifierCommandClause, defaultArgumentValues);
+            await printSecretArgsWarning(context, parseResult);
             if (parseResult.invalidArguments.length > 0) {
                 await printParseResultError(context, parseResult);
                 return {
@@ -186,7 +187,7 @@ async function findAndExecuteNonModifierCommand(availableArgs, unusedArgs, nonMo
     unusedArgs.push(...scanResult.unusedArgSequences);
     if (scanResult.nonModifierCommandClause) {
         const defaultArgumentValues = configurationServiceProvider
-            ? await configurationServiceProvider.getDefaultArgumentValues(context.cliConfig, scanResult.nonModifierCommandClause.command)
+            ? await configurationServiceProvider.getDefaultArgumentValues(context.cliConfig, scanResult.nonModifierCommandClause.command, scanResult.nonModifierCommandClause.groupCommand)
             : undefined;
         if (isGlobalCommand(scanResult.nonModifierCommandClause.command)) {
             parseResult = parseGlobalCommandClause(scanResult.nonModifierCommandClause, defaultArgumentValues);
@@ -194,6 +195,7 @@ async function findAndExecuteNonModifierCommand(availableArgs, unusedArgs, nonMo
         else {
             parseResult = parseSubCommandClause(scanResult.nonModifierCommandClause, defaultArgumentValues);
         }
+        await printSecretArgsWarning(context, parseResult);
         if (parseResult.invalidArguments.length > 0) {
             const prompted = await attemptPromptForMissingArguments(parseResult, context);
             if (prompted) {
@@ -298,6 +300,7 @@ async function findAndExecuteDefaultNonModifierCommand(availableArgs, unusedArgs
                 potentialArgs: [...argSequence],
             }, defaultArgumentValues);
         }
+        await printSecretArgsWarning(context, parseResult);
         // add any unused args back to the list of still unused args
         if (parseResult.unusedArgs.length > 0) {
             unusedArgs.push(parseResult.unusedArgs);

package/dist/src/runtime/values/ValuePopulationResult.d.ts

@@ -12,6 +12,10 @@ export interface ValuePopulationResult {
      * Any invalid argument discovered while populating values.
      */
     readonly invalidArgument?: InvalidArgument;
+    /**
+     * Names of any SECRET arguments whose values were supplied as plain command line arguments.
+     */
+    readonly secretArgumentNames?: ReadonlyArray<string>;
 }
 /**
  * A container holding the result of argument values population for a {@link SubCommand}.

package/dist/src/runtime/values/ValuePopulationResult.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ValuePopulationResult.d.ts","sourceRoot":"","sources":["../../../../src/runtime/values/ValuePopulationResult.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,wBAAwB,EACxB,eAAe,EAChB,MAAM,yCAAyC,CAAC;AACjD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAE/E;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;OAEG;IACH,QAAQ,CAAC,UAAU,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAE3C;;OAEG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,eAAe,CAAC;CAC5C;AAED;;GAEG;AACH,MAAM,WAAW,+BAAgC,SAAQ,qBAAqB;IAC5E;;OAEG;IACH,QAAQ,CAAC,uBAAuB,EAAE,eAAe,CAAC;CACnD;AAED;;GAEG;AACH,MAAM,WAAW,kCAAmC,SAAQ,qBAAqB;IAC/E;;OAEG;IACH,QAAQ,CAAC,sBAAsB,EAAE,wBAAwB,CAAC;CAC3D"}
+{"version":3,"file":"ValuePopulationResult.d.ts","sourceRoot":"","sources":["../../../../src/runtime/values/ValuePopulationResult.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,wBAAwB,EACxB,eAAe,EAChB,MAAM,yCAAyC,CAAC;AACjD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAE/E;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;OAEG;IACH,QAAQ,CAAC,UAAU,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAE3C;;OAEG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,eAAe,CAAC;IAE3C;;OAEG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CACtD;AAED;;GAEG;AACH,MAAM,WAAW,+BAAgC,SAAQ,qBAAqB;IAC5E;;OAEG;IACH,QAAQ,CAAC,uBAAuB,EAAE,eAAe,CAAC;CACnD;AAED;;GAEG;AACH,MAAM,WAAW,kCAAmC,SAAQ,qBAAqB;IAC/E;;OAEG;IACH,QAAQ,CAAC,sBAAsB,EAAE,wBAAwB,CAAC;CAC3D"}

package/dist/src/runtime/values/globalCommandValuePopulation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"globalCommandValuePopulation.d.ts","sourceRoot":"","sources":["../../../../src/runtime/values/globalCommandValuePopulation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yCAAyC,CAAC;AAC7E,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,4BAA4B,CAAC;AAErF,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,yCAAyC,CAAC;AAMxF;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,UAAU,0BAA0B,CAChD,aAAa,EAAE,aAAa,EAC5B,aAAa,EAAE,aAAa,CAAC,MAAM,CAAC,EACpC,YAAY,EAAE,wBAAwB,GACrC,kCAAkC,CAkEpC"}
+{"version":3,"file":"globalCommandValuePopulation.d.ts","sourceRoot":"","sources":["../../../../src/runtime/values/globalCommandValuePopulation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yCAAyC,CAAC;AAC7E,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,4BAA4B,CAAC;AAErF,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,yCAAyC,CAAC;AAOxF;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,UAAU,0BAA0B,CAChD,aAAa,EAAE,aAAa,EAC5B,aAAa,EAAE,aAAa,CAAC,MAAM,CAAC,EACpC,YAAY,EAAE,wBAAwB,GACrC,kCAAkC,CAwEpC"}

package/dist/src/runtime/values/globalCommandValuePopulation.js

@@ -1,5 +1,6 @@
 import { ValueTypeName } from "@flowscripter/dynamic-cli-framework-api";
 import getLogger from "../../util/logger.js";
+import { REDACTED } from "../../util/secretRedaction.js";
 import { InvalidArgumentReason } from "@flowscripter/dynamic-cli-framework-api";
 const logger = getLogger("globalCommandValuePopulation");
 /**
@@ -10,14 +11,20 @@ const logger = getLogger("globalCommandValuePopulation");
  * @param defaultValue optional default value to use for population before parsing the provided arguments.
  */
 export default function populateGlobalCommandValue(globalCommand, potentialArgs, defaultValue) {
+    const argument = globalCommand.argument;
+    const isSecret = argument.type === ValueTypeName.SECRET;
     logger.debug(() => {
-        const message = `Populating value for global command: '${globalCommand.name}' using potential args: ${potentialArgs.join(" ")}`;
+        const message = `Populating value for global command: '${globalCommand.name}' using potential args: ${(isSecret
+            ? potentialArgs
+                .slice(0, 1)
+                .map(() => REDACTED)
+                .concat(potentialArgs.slice(1))
+            : potentialArgs).join(" ")}`;
         if (defaultValue !== undefined) {
-            return `${message} and configured value: '${defaultValue}'`;
+            return `${message} and configured value: '${isSecret ? REDACTED : defaultValue}'`;
         }
         return message;
     });
-    const argument = globalCommand.argument;
     // default to defined argument default value
     let populatedArgumentValue = argument.defaultValue;
     // override with provided configured value
@@ -63,5 +70,6 @@ export default function populateGlobalCommandValue(globalCommand, potentialArgs,
     return {
         populatedArgumentValue,
         unusedArgs,
+        ...(isSecret && potentialArgs.length > 0 && { secretArgumentNames: [globalCommand.name] }),
     };
 }

package/dist/src/runtime/values/subCommandValuePopulation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"subCommandValuePopulation.d.ts","sourceRoot":"","sources":["../../../../src/runtime/values/subCommandValuePopulation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yCAAyC,CAAC;AAC1E,OAAO,EAIL,KAAK,eAAe,EAErB,MAAM,yCAAyC,CAAC;AAGjD,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,4BAA4B,CAAC;AAsjBlF;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,UAAU,wBAAwB,CAC9C,UAAU,EAAE,UAAU,EACtB,aAAa,EAAE,aAAa,CAAC,MAAM,CAAC,EACpC,aAAa,EAAE,eAAe,GAAG,SAAS,GACzC,+BAA+B,CAkEjC"}
+{"version":3,"file":"subCommandValuePopulation.d.ts","sourceRoot":"","sources":["../../../../src/runtime/values/subCommandValuePopulation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yCAAyC,CAAC;AAC1E,OAAO,EAIL,KAAK,eAAe,EAErB,MAAM,yCAAyC,CAAC;AAIjD,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,4BAA4B,CAAC;AA2kBlF;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,UAAU,wBAAwB,CAC9C,UAAU,EAAE,UAAU,EACtB,aAAa,EAAE,aAAa,CAAC,MAAM,CAAC,EACpC,aAAa,EAAE,eAAe,GAAG,SAAS,GACzC,+BAA+B,CA+EjC"}

package/dist/src/runtime/values/subCommandValuePopulation.js

@@ -1,5 +1,6 @@
 import { ValueTypeName, } from "@flowscripter/dynamic-cli-framework-api";
 import getLogger from "../../util/logger.js";
+import { REDACTED, redactSubCommandValues } from "../../util/secretRedaction.js";
 import argumentValueMerge from "./argumentValueMerge.js";
 import { MAXIMUM_COMPLEX_OPTION_NESTING_DEPTH } from "@flowscripter/dynamic-cli-framework-api";
 import { isComplexOption } from "../argument/ArgumentTypeGuards.js";
@@ -62,6 +63,18 @@ class ParseContext {
      * which will be populated with a positional value if found.
      */
     currentPositionalIndex;
+    /**
+     * Set when the most recent argument supplied a value for a SECRET option or positional.
+     */
+    secretArgument;
+    /**
+     * Return and clear the {@link secretArgument} recorded by the most recent {@link parse}.
+     */
+    takeSecretArgument() {
+        const secretArgument = this.secretArgument;
+        this.secretArgument = undefined;
+        return secretArgument;
+    }
     /**
      * Use to store lazily created map of option paths e.g. --alpha.b.g and -a.b.gamma for {@link ComplexOption} or {@link Option} instances.
      */
@@ -294,7 +307,10 @@ 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) {
+    setOptionValue(value, inline = false) {
+        if (this.currentOption.type === ValueTypeName.SECRET) {
+            this.secretArgument = { name: this.currentOption.name, inline };
+        }
         let optionValue = this.populatedArgumentValues;
         const optionPath = this.currentOptionPath;
         // traverse the current populated values using the validated option path elements
@@ -367,6 +383,9 @@ class ParseContext {
     setPositionalValue(value) {
         const positional = this.subCommand.positionals[this.currentPositionalIndex];
         const currentValue = this.populatedArgumentValues[positional.name];
+        if (positional.type === ValueTypeName.SECRET) {
+            this.secretArgument = { name: positional.name, inline: false };
+        }
         // if we haven't populated the argument value before...
         if (currentValue === undefined) {
             if (positional.isVarargMultiple) {
@@ -460,7 +479,7 @@ class ParseContext {
                     // try to set the value if we have one
                     if (potentialOptionValue !== undefined) {
                         // set the value
-                        this.setOptionValue(potentialOptionValue);
+                        this.setOptionValue(potentialOptionValue, true);
                         // return regardless
                         return;
                     }
@@ -491,19 +510,21 @@ class ParseContext {
  * @param defaultValues optional default {@link Values} to use for population before parsing the provided arguments.
  */
 export default function populateSubCommandValues(subCommand, potentialArgs, defaultValues) {
-    logger.debug(() => {
-        const message = `Populating values for sub-command: '${subCommand.name}' using potential args: ${potentialArgs.join(" ")}`;
-        if (defaultValues !== undefined) {
-            return `${message} and configured values: ${JSON.stringify(defaultValues)}`;
-        }
-        return message;
-    });
     const parseContext = new ParseContext(subCommand);
     const unusedArgs = [];
+    const loggedArgs = [...potentialArgs];
+    const secretArgumentNames = new Set();
     for (let i = 0; i < potentialArgs.length; i++) {
         const potentialArg = potentialArgs[i];
         // parse the next arg
         parseContext.parse(potentialArg);
+        const secretArgument = parseContext.takeSecretArgument();
+        if (secretArgument) {
+            secretArgumentNames.add(secretArgument.name);
+            loggedArgs[i] = secretArgument.inline
+                ? `${potentialArg.slice(0, potentialArg.indexOf("=") + 1)}${REDACTED}`
+                : REDACTED;
+        }
         // check if we had a parsing error, record the error, flush the remaining args and stop parsing
         if (parseContext.state === ParseState.ERROR) {
             if (i + 1 < potentialArgs.length) {
@@ -517,6 +538,13 @@ export default function populateSubCommandValues(subCommand, potentialArgs, defa
             parseContext.state = ParseState.EMPTY;
         }
     }
+    logger.debug(() => {
+        const message = `Populated values for sub-command: '${subCommand.name}' using potential args: ${loggedArgs.join(" ")}`;
+        if (defaultValues !== undefined) {
+            return `${message} and configured values: ${JSON.stringify(redactSubCommandValues(subCommand, defaultValues))}`;
+        }
+        return message;
+    });
     // 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`
@@ -536,6 +564,7 @@ export default function populateSubCommandValues(subCommand, potentialArgs, defa
             populatedArgumentValues: parseContext.populatedArgumentValues,
             unusedArgs: unusedArgs,
             invalidArgument: parseContext.invalidArgument,
+            ...(secretArgumentNames.size > 0 && { secretArgumentNames: [...secretArgumentNames] }),
         };
     }
     // merge the configured values with the parsed values
@@ -546,5 +575,6 @@ export default function populateSubCommandValues(subCommand, potentialArgs, defa
     return {
         populatedArgumentValues,
         unusedArgs: unusedArgs,
+        ...(secretArgumentNames.size > 0 && { secretArgumentNames: [...secretArgumentNames] }),
     };
 }

package/dist/src/service/configuration/ConfigurationServiceProvider.d.ts

@@ -1,6 +1,7 @@
 import type { ServiceInfo, ServiceProvider } from "@flowscripter/dynamic-cli-framework-api";
 import type { SingleValueType, Values, ValueNode, PopulatedValues, PopulatedValueType } from "@flowscripter/dynamic-cli-framework-api";
 import type { Context } from "@flowscripter/dynamic-cli-framework-api";
+import type { GroupCommand } from "@flowscripter/dynamic-cli-framework-api";
 import type { Command } from "@flowscripter/dynamic-cli-framework-api";
 import type { CLIConfig } from "@flowscripter/dynamic-cli-framework-api";
 export type KeyValueServiceScopeType = "command" | "service";
@@ -27,7 +28,8 @@ export type KeyValueServiceScopeType = "command" | "service";
  *
  * 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 Values}. As an example:
+ * (or `<group name>:<member name>` for a member of a {@link GroupCommand}) and the contained values are treated as
+ * command {@link Values}. As an example:
  *
  * ```
  * {
@@ -44,6 +46,9 @@ export type KeyValueServiceScopeType = "command" | "service";
  *         "command2": {
  *             "arg4": true
  *         },
+ *         "group1:member1": {
+ *             "arg5": "bar"
+ *         },
  *         "globalCommand": "globalArgumentValue"
  *     },
  *     "key-values": {
@@ -74,13 +79,15 @@ export type KeyValueServiceScopeType = "command" | "service";
  * 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.
+ * is additionally prefixed with the {@link CLIConfig.name}, the {@link GroupCommand.name} (if the command is a group
+ * member) 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`, group: `group1`, member command: `member1`, simple root argument: `arg1` => environment variable: `MYCLI_GROUP1_MEMBER1_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`
@@ -127,8 +134,10 @@ export default class ConfigurationServiceProvider implements ServiceProvider {
      *
      * @param cliConfig the {@link CLIConfig} to use for retrieving configuration keys.
      * @param command the {@link Command} instance to retrieve default argument values for.
+     * @param groupCommand the {@link GroupCommand} if the command is a group member. The configuration file key
+     * is then `<group name>:<command name>` and the env var names include the group name.
      */
-    getDefaultArgumentValues(cliConfig: CLIConfig, command: Command): Promise<PopulatedValues | PopulatedValueType | undefined>;
+    getDefaultArgumentValues(cliConfig: CLIConfig, command: Command, groupCommand?: GroupCommand): Promise<PopulatedValues | PopulatedValueType | undefined>;
     /**
      * Get-or-create the underlying, raw {@link ValueNode} `Map` for the given scope - for
      * {@link KeyValueServiceProvider}'s exclusive use, via its direct reference to this provider.

package/dist/src/service/configuration/ConfigurationServiceProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ConfigurationServiceProvider.d.ts","sourceRoot":"","sources":["../../../../src/service/configuration/ConfigurationServiceProvider.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAE5F,OAAO,KAAK,EACV,eAAe,EACf,MAAM,EACN,SAAS,EACT,eAAe,EACf,kBAAkB,EACnB,MAAM,yCAAyC,CAAC;AAEjD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yCAAyC,CAAC;AASvE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yCAAyC,CAAC;AAOvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAQzE,MAAM,MAAM,wBAAwB,GAAG,SAAS,GAAG,SAAS,CAAC;AAkB7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8FG;AACH,MAAM,CAAC,OAAO,OAAO,4BAA6B,YAAW,eAAe;;IAC1E,QAAQ,CAAC,SAAS,EAAE,MAAM,CAA4B;IACtD,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IAEjC,SAAgB,cAAc,EAAE,OAAO,CAAC;IACxC,SAAgB,aAAa,EAAE,OAAO,CAAC;IACvC,SAAgB,oBAAoB,EAAE,OAAO,CAAC;IAGvC,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC;IAKnC,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe,CAAC,CAAa;IAqBvE;;;;;;;;OAQG;IACH,YACE,eAAe,EAAE,MAAM,EACvB,cAAc,UAAQ,EACtB,aAAa,UAAQ,EACrB,oBAAoB,UAAQ,EAW7B;IAEM,cAAc,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,WAAW,CAAC,CAehE;IAEM,iBAAiB,CAAC,cAAc,EAAE,MAAM,QAE9C;IAED;;;;;;;OAOG;IACU,wBAAwB,CACnC,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,eAAe,GAAG,kBAAkB,GAAG,SAAS,CAAC,CAoD3D;IAED;;;;;;OAMG;IACI,eAAe,CACpB,SAAS,EAAE,wBAAwB,EACnC,QAAQ,EAAE,MAAM,GACf,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAOxB;IAED;;;;;;OAMG;IACU,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAQzD;IAEY,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CA0CxD;IA4DM,eAAe,IAAI,MAAM,CAgC/B;CACF"}
+{"version":3,"file":"ConfigurationServiceProvider.d.ts","sourceRoot":"","sources":["../../../../src/service/configuration/ConfigurationServiceProvider.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAE5F,OAAO,KAAK,EACV,eAAe,EACf,MAAM,EACN,SAAS,EACT,eAAe,EACf,kBAAkB,EACnB,MAAM,yCAAyC,CAAC;AAEjD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AAS5E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yCAAyC,CAAC;AAOvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAQzE,MAAM,MAAM,wBAAwB,GAAG,SAAS,GAAG,SAAS,CAAC;AAkB7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoGG;AACH,MAAM,CAAC,OAAO,OAAO,4BAA6B,YAAW,eAAe;;IAC1E,QAAQ,CAAC,SAAS,EAAE,MAAM,CAA4B;IACtD,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IAEjC,SAAgB,cAAc,EAAE,OAAO,CAAC;IACxC,SAAgB,aAAa,EAAE,OAAO,CAAC;IACvC,SAAgB,oBAAoB,EAAE,OAAO,CAAC;IAGvC,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC;IAKnC,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe,CAAC,CAAa;IAqBvE;;;;;;;;OAQG;IACH,YACE,eAAe,EAAE,MAAM,EACvB,cAAc,UAAQ,EACtB,aAAa,UAAQ,EACrB,oBAAoB,UAAQ,EAW7B;IAEM,cAAc,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,WAAW,CAAC,CAehE;IAEM,iBAAiB,CAAC,cAAc,EAAE,MAAM,QAE9C;IAED;;;;;;;;;OASG;IACU,wBAAwB,CACnC,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,OAAO,EAChB,YAAY,CAAC,EAAE,YAAY,GAC1B,OAAO,CAAC,eAAe,GAAG,kBAAkB,GAAG,SAAS,CAAC,CAsD3D;IAED;;;;;;OAMG;IACI,eAAe,CACpB,SAAS,EAAE,wBAAwB,EACnC,QAAQ,EAAE,MAAM,GACf,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAOxB;IAED;;;;;;OAMG;IACU,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAQzD;IAEY,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CA0CxD;IA4DM,eAAe,IAAI,MAAM,CAgC/B;CACF"}

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

@@ -47,7 +47,8 @@ class ConfigurationServiceImpl {
  *
  * 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 Values}. As an example:
+ * (or `<group name>:<member name>` for a member of a {@link GroupCommand}) and the contained values are treated as
+ * command {@link Values}. As an example:
  *
  * ```
  * {
@@ -64,6 +65,9 @@ class ConfigurationServiceImpl {
  *         "command2": {
  *             "arg4": true
  *         },
+ *         "group1:member1": {
+ *             "arg5": "bar"
+ *         },
  *         "globalCommand": "globalArgumentValue"
  *     },
  *     "key-values": {
@@ -94,13 +98,15 @@ class ConfigurationServiceImpl {
  * 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.
+ * is additionally prefixed with the {@link CLIConfig.name}, the {@link GroupCommand.name} (if the command is a group
+ * member) 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`, group: `group1`, member command: `member1`, simple root argument: `arg1` => environment variable: `MYCLI_GROUP1_MEMBER1_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`
@@ -191,20 +197,23 @@ export default class ConfigurationServiceProvider {
      *
      * @param cliConfig the {@link CLIConfig} to use for retrieving configuration keys.
      * @param command the {@link Command} instance to retrieve default argument values for.
+     * @param groupCommand the {@link GroupCommand} if the command is a group member. The configuration file key
+     * is then `<group name>:<command name>` and the env var names include the group name.
      */
-    async getDefaultArgumentValues(cliConfig, command) {
+    async getDefaultArgumentValues(cliConfig, command, groupCommand) {
         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);
+        const commandKey = groupCommand ? `${groupCommand.name}:${command.name}` : command.name;
+        logger.debug("getting default argument values for command: %s", commandKey);
         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 configuredValue = this.defaultsData.get(commandKey);
             const envVarValue = this.envVarsEnabled
                 ? getGlobalCommandValueFromEnvVars(cliConfig, command)
                 : undefined;
@@ -212,9 +221,9 @@ export default class ConfigurationServiceProvider {
             result = envVarValue !== undefined ? envVarValue : configuredValue;
         }
         else if (isSubCommand(command)) {
-            const configuredValues = this.defaultsData.get(command.name);
+            const configuredValues = this.defaultsData.get(commandKey);
             const envVarValues = this.envVarsEnabled
-                ? getSubCommandValuesFromEnvVars(cliConfig, command)
+                ? getSubCommandValuesFromEnvVars(cliConfig, command, groupCommand)
                 : undefined;
             if (envVarValues === undefined) {
                 result = configuredValues;

package/dist/src/util/configHelper.d.ts

@@ -1,3 +1,4 @@
+import type { GroupCommand } from "@flowscripter/dynamic-cli-framework-api";
 import type { Command } from "@flowscripter/dynamic-cli-framework-api";
 import type { CLIConfig } from "@flowscripter/dynamic-cli-framework-api";
 import type { SubCommandArgument } from "@flowscripter/dynamic-cli-framework-api";
@@ -9,8 +10,10 @@ import type { GlobalCommandArgument } from "@flowscripter/dynamic-cli-framework-
  * @param command the {@link Command} to use for determining the default configuration key.
  * @param argumentAncestry a list of {@link SubCommandArgument} instances from the root command arguments to a leaf argument.
  * Apart from {@link ComplexOption} instances this will always only have a single entry.
+ * @param groupCommand the {@link GroupCommand} if the command is a member of a group, in which case the group name
+ * is an additional key segment.
  */
-export declare function getSubCommandArgumentConfigurationKey(cliConfig: CLIConfig, command: Command, argumentAncestry: Array<SubCommandArgument>): string | undefined;
+export declare function getSubCommandArgumentConfigurationKey(cliConfig: CLIConfig, command: Command, argumentAncestry: Array<SubCommandArgument>, groupCommand?: GroupCommand): string | undefined;
 /**
  * Determine the configuration key for the specified {@link GlobalCommandArgument}.
  *

package/dist/src/util/configHelper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"configHelper.d.ts","sourceRoot":"","sources":["../../../src/util/configHelper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAGzE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yCAAyC,CAAC;AAClF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,yCAAyC,CAAC;AAgBrF;;;;;;;GAOG;AACH,wBAAgB,qCAAqC,CACnD,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,OAAO,EAChB,gBAAgB,EAAE,KAAK,CAAC,kBAAkB,CAAC,GAC1C,MAAM,GAAG,SAAS,CA2BpB;AAED;;;;;;GAMG;AACH,wBAAgB,wCAAwC,CACtD,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,OAAO,EAChB,qBAAqB,EAAE,qBAAqB,GAC3C,MAAM,GAAG,SAAS,CAcpB"}
+{"version":3,"file":"configHelper.d.ts","sourceRoot":"","sources":["../../../src/util/configHelper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AAC5E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAGzE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yCAAyC,CAAC;AAClF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,yCAAyC,CAAC;AAgBrF;;;;;;;;;GASG;AACH,wBAAgB,qCAAqC,CACnD,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,OAAO,EAChB,gBAAgB,EAAE,KAAK,CAAC,kBAAkB,CAAC,EAC3C,YAAY,CAAC,EAAE,YAAY,GAC1B,MAAM,GAAG,SAAS,CA8BpB;AAED;;;;;;GAMG;AACH,wBAAgB,wCAAwC,CACtD,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,OAAO,EAChB,qBAAqB,EAAE,qBAAqB,GAC3C,MAAM,GAAG,SAAS,CAcpB"}

package/dist/src/util/configHelper.js

@@ -18,8 +18,10 @@ function getKeySegment(segment, isCustom = false, isArray = false) {
  * @param command the {@link Command} to use for determining the default configuration key.
  * @param argumentAncestry a list of {@link SubCommandArgument} instances from the root command arguments to a leaf argument.
  * Apart from {@link ComplexOption} instances this will always only have a single entry.
+ * @param groupCommand the {@link GroupCommand} if the command is a member of a group, in which case the group name
+ * is an additional key segment.
  */
-export function getSubCommandArgumentConfigurationKey(cliConfig, command, argumentAncestry) {
+export function getSubCommandArgumentConfigurationKey(cliConfig, command, argumentAncestry, groupCommand) {
     if (command.enableConfiguration === undefined || command.enableConfiguration !== true) {
         return undefined;
     }
@@ -30,6 +32,9 @@ export function getSubCommandArgumentConfigurationKey(cliConfig, command, argume
     const firstArgument = argumentAncestry[0];
     if (firstArgument.configurationKey === undefined) {
         keySegments.push(getKeySegment(cliConfig.name));
+        if (groupCommand) {
+            keySegments.push(getKeySegment(groupCommand.name));
+        }
         keySegments.push(getKeySegment(command.name));
     }
     argumentAncestry.forEach((argument) => {

package/dist/src/util/envVarHelper.d.ts

@@ -1,6 +1,7 @@
 import type { CLIConfig } from "@flowscripter/dynamic-cli-framework-api";
 import { type PopulatedSingleValueType, type PopulatedValues } from "@flowscripter/dynamic-cli-framework-api";
 import type { GlobalCommand } from "@flowscripter/dynamic-cli-framework-api";
+import type { GroupCommand } from "@flowscripter/dynamic-cli-framework-api";
 import type { SubCommand } from "@flowscripter/dynamic-cli-framework-api";
 /**
  * Get configured argument value for the specified {@link GlobalCommandArgument} from environment variables.
@@ -16,6 +17,8 @@ export declare function getGlobalCommandValueFromEnvVars(cliConfig: CLIConfig, c
  * @param cliConfig the {@link CLIConfig} to use for determining the default configuration key.
  * @param command the {@link SubCommand} to use for determining the default configuration key and containing
  * {@link Positional} and {@link Option} instances to populate values for.
+ * @param groupCommand the {@link GroupCommand} if the command is a group member, in which case the group name
+ * is an additional env var name segment.
  */
-export declare function getSubCommandValuesFromEnvVars(cliConfig: CLIConfig, command: SubCommand): PopulatedValues | undefined;
+export declare function getSubCommandValuesFromEnvVars(cliConfig: CLIConfig, command: SubCommand, groupCommand?: GroupCommand): PopulatedValues | undefined;
 //# sourceMappingURL=envVarHelper.d.ts.map

package/dist/src/util/envVarHelper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"envVarHelper.d.ts","sourceRoot":"","sources":["../../../src/util/envVarHelper.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACzE,OAAO,EAGL,KAAK,wBAAwB,EAC7B,KAAK,eAAe,EACrB,MAAM,yCAAyC,CAAC;AAOjD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yCAAyC,CAAC;AAC7E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yCAAyC,CAAC;AAmC1E;;;;;;GAMG;AACH,wBAAgB,gCAAgC,CAC9C,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,aAAa,GACrB,wBAAwB,CAa1B;AAwID;;;;;;GAMG;AACH,wBAAgB,8BAA8B,CAC5C,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,UAAU,GAClB,eAAe,GAAG,SAAS,CA4E7B"}
+{"version":3,"file":"envVarHelper.d.ts","sourceRoot":"","sources":["../../../src/util/envVarHelper.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACzE,OAAO,EAGL,KAAK,wBAAwB,EAC7B,KAAK,eAAe,EACrB,MAAM,yCAAyC,CAAC;AAOjD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yCAAyC,CAAC;AAC7E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AAC5E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yCAAyC,CAAC;AAqC1E;;;;;;GAMG;AACH,wBAAgB,gCAAgC,CAC9C,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,aAAa,GACrB,wBAAwB,CAa1B;AAwID;;;;;;;;GAQG;AACH,wBAAgB,8BAA8B,CAC5C,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,UAAU,EACnB,YAAY,CAAC,EAAE,YAAY,GAC1B,eAAe,GAAG,SAAS,CAsF7B"}